diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml
new file mode 100644
index 000000000..da894d121
--- /dev/null
+++ b/.github/workflows/tests.yml
@@ -0,0 +1,49 @@
+name: Tests
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.9", "3.10", "3.11", "3.12", "3.13", "3.14"]
+    steps:
+    - uses: actions/checkout@v3
+
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v4
+      with:
+        python-version: ${{ matrix.python-version }}
+        allow-prereleases: true
+
+    - name: Install dependencies
+      run: |
+        pip install --upgrade pip wheel setuptools
+        pip install -r requirements_test.txt
+        pip install flake8
+        bash ./tools/build_talib_linux.sh
+
+    - name: Build cython modules in-place
+      run: |
+        python setup.py build_ext --inplace
+      env:
+        TA_INCLUDE_PATH: "ta-lib-install/include"
+        TA_LIBRARY_PATH: "ta-lib-install/lib"
+
+    - name: Lint with flake8
+      run: |
+        # stop the build if there are Python syntax errors or undefined names
+        flake8 talib --count --select=E9,F63,F7,F82 --show-source --statistics
+        # exit-zero treats all errors as warnings. The GitHub editor is 127 chars wide
+        #flake8 talib --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics
+
+    - name: Test with pytest
+      run: |
+        PYTHONPATH=. pytest
+      env:
+        LD_LIBRARY_PATH: "ta-lib-install/lib"
diff --git a/.github/workflows/wheels.yml b/.github/workflows/wheels.yml
new file mode 100644
index 000000000..5d922c974
--- /dev/null
+++ b/.github/workflows/wheels.yml
@@ -0,0 +1,249 @@
+
+name: Wheels
+on:
+  push:
+    tags:
+      - "v*"
+  workflow_dispatch:
+
+env:
+  TALIB_C_VER: 0.6.4
+  PIP_NO_VERIFY: 0
+  PIP_VERBOSE: 1
+  CIBW_BEFORE_BUILD: pip install -U setuptools Cython wheel meson-python ninja && pip install -U numpy
+  CIBW_TEST_REQUIRES: pytest pandas maturin polars
+  CIBW_SKIP: "pp* cp313t* cp314t*"
+
+jobs:
+  build_linux_x86_64:
+    name: Build Linux x86_64 wheels
+    strategy:
+      matrix:
+        os: ["ubuntu-24.04"]
+    runs-on: ${{ matrix.os }}
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+      - name: Build wheels
+        uses: pypa/cibuildwheel@v3.2.1
+        env:
+          CIBW_BEFORE_ALL: |
+              bash ./tools/build_talib_linux.sh
+          CIBW_MANYLINUX_X86_64_IMAGE: manylinux_2_28
+          CIBW_MUSLLINUX_X86_64_IMAGE: musllinux_1_2
+          CIBW_TEST_SKIP: "cp*-musllinux*"
+          CIBW_TEST_COMMAND: >
+            cd .. &&
+            pytest -k "not RSI and not threading" {project}/tests
+          CIBW_ARCHS_LINUX: x86_64
+          CIBW_BUILD_FRONTEND: build
+          CIBW_ENVIRONMENT_LINUX : >
+            TA_LIBRARY_PATH="ta-lib-install/lib"
+            TA_INCLUDE_PATH="ta-lib-install/include"
+            PIP_NO_BUILD_ISOLATION=false
+          CIBW_REPAIR_WHEEL_COMMAND_LINUX: |
+            export LD_LIBRARY_PATH="/project/ta-lib-install/lib:$LD_LIBRARY_PATH"
+            auditwheel repair -w {dest_dir} {wheel}
+      - name: Upload wheels
+        uses: actions/upload-artifact@v4
+        with:
+          path: ./wheelhouse/*.whl
+          name: "ta_lib-${{ github.ref_name }}-linux_x86_64"
+  build_linux_arm64:
+    name: Build Linux arm64 wheels
+    strategy:
+      matrix:
+        os: ["ubuntu-24.04-arm"]
+    runs-on: ${{ matrix.os }}
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+      - name: Build wheels
+        uses: pypa/cibuildwheel@v3.2.1
+        env:
+          CIBW_BEFORE_ALL: |
+              bash ./tools/build_talib_linux.sh
+          CIBW_MANYLINUX_AARCH64_IMAGE: manylinux_2_28
+          CIBW_MUSLLINUX_AARCH64_IMAGE: musllinux_1_2
+          CIBW_TEST_SKIP: "cp*-musllinux*"
+          CIBW_TEST_COMMAND: >
+            cd .. &&
+            pytest -k "not RSI and not threading" {project}/tests
+          CIBW_ARCHS_LINUX: aarch64
+          CIBW_BUILD_FRONTEND: build
+          CIBW_ENVIRONMENT_LINUX : >
+            TA_LIBRARY_PATH="ta-lib-install/lib"
+            TA_INCLUDE_PATH="ta-lib-install/include"
+            PIP_NO_BUILD_ISOLATION=false
+          CIBW_REPAIR_WHEEL_COMMAND_LINUX: |
+            export LD_LIBRARY_PATH="/project/ta-lib-install/lib:$LD_LIBRARY_PATH"
+            auditwheel repair -w {dest_dir} {wheel}
+      - name: Upload wheels
+        uses: actions/upload-artifact@v4
+        with:
+          path: ./wheelhouse/*.whl
+          name: "ta_lib-${{ github.ref_name }}-linux_arm64"
+  build_windows_amd64:
+    name: Build Windows amd64 wheels
+    strategy:
+      matrix:
+        os: ["windows-2022"]
+    runs-on: ${{ matrix.os }}
+    steps:
+      - name: Checkout the repository
+        uses: actions/checkout@v4
+      - name: Set up MSVC for x64
+        uses: ilammy/msvc-dev-cmd@v1
+        with:
+          arch: amd64
+      - name: Build TA-Lib C Library
+        run: tools/build_talib_windows.cmd
+        shell: cmd
+      - name: Build wheels
+        uses: pypa/cibuildwheel@v3.2.1
+        env:
+          CIBW_TEST_SKIP: "cp*"
+          CIBW_TEST_COMMAND: >
+            cd .. &&
+            pytest --rootdir=C: -k "not RSI and not threading" {project}/tests
+          MSBUILDTREATHIGHERTOOLSVERSIONASCURRENT: 1
+          CIBW_ARCHS_WINDOWS: AMD64
+          CIBW_ENVIRONMENT_WINDOWS: >
+            TA_LIBRARY_PATH="ta-lib-$TALIB_C_VER\\_build;$LIB"
+            TA_INCLUDE_PATH="ta-lib-$TALIB_C_VER\\include;$INCLUDE"
+            PIP_NO_BUILD_ISOLATION=false
+      - name: Upload wheel
+        uses: actions/upload-artifact@v4
+        with:
+          path: ./wheelhouse/*.whl
+          name: "ta_lib-${{ github.ref_name }}-win_amd64"
+  build_windows_x86:
+    name: Build Windows x86 wheels
+    strategy:
+      matrix:
+        os: ["windows-2022"]
+    runs-on: ${{ matrix.os }}
+    steps:
+      - name: Checkout the repository
+        uses: actions/checkout@v4
+      - name: Set up MSVC for x86
+        uses: ilammy/msvc-dev-cmd@v1
+        with:
+          arch: amd64_x86
+      - name: Build TA-Lib C library
+        run: tools/build_talib_windows.cmd
+        shell: cmd
+      - name: Build wheels
+        uses: pypa/cibuildwheel@v3.2.1
+        env:
+          CIBW_TEST_SKIP: "cp*"
+          CIBW_TEST_COMMAND: >
+            cd .. &&
+            pytest --rootdir=C: -k "not RSI and not threading" {project}/tests
+          MSBUILDTREATHIGHERTOOLSVERSIONASCURRENT: 1
+          CIBW_ARCHS_WINDOWS: x86
+          CIBW_ENVIRONMENT_WINDOWS: >
+            TA_LIBRARY_PATH="ta-lib-$TALIB_C_VER\\_build;$LIB"
+            TA_INCLUDE_PATH="ta-lib-$TALIB_C_VER\\include;$INCLUDE"
+            PIP_NO_BUILD_ISOLATION=false
+      - name: Upload wheel
+        uses: actions/upload-artifact@v4
+        with:
+          path: ./wheelhouse/*.whl
+          name: "ta_lib-${{ github.ref_name }}-win32"
+  build_windows_arm64:
+    name: Build Windows arm64 wheels
+    strategy:
+      matrix:
+        os: ["windows-11-arm"]
+    runs-on: ${{ matrix.os }}
+    steps:
+      - name: Checkout the repository
+        uses: actions/checkout@v4
+      - name: Set up MSVC for arm
+        uses: ilammy/msvc-dev-cmd@v1
+        with:
+          arch: arm64
+      - name: Build TA-Lib C Library
+        run: tools/build_talib_windows.cmd
+        shell: cmd
+      - name: Build wheels
+        uses: pypa/cibuildwheel@v3.2.1
+        env:
+          CIBW_TEST_SKIP: "cp*"
+          CIBW_TEST_COMMAND: >
+            cd .. &&
+            pytest --rootdir=C: -k "not RSI and not threading" {project}/tests
+          MSBUILDTREATHIGHERTOOLSVERSIONASCURRENT: 1
+          CIBW_ARCHS_WINDOWS: ARM64
+          CIBW_ENVIRONMENT_WINDOWS: >
+            TA_LIBRARY_PATH="ta-lib-$TALIB_C_VER\\_build;$LIB"
+            TA_INCLUDE_PATH="ta-lib-$TALIB_C_VER\\include;$INCLUDE"
+            PIP_NO_BUILD_ISOLATION=false
+      - name: Upload wheel
+        uses: actions/upload-artifact@v4
+        with:
+          path: ./wheelhouse/*.whl
+          name: "ta_lib-${{ github.ref_name }}-win_arm64"
+  build_macos_x86_64:
+    name: Build MacOS x86_64 wheels
+    strategy:
+      matrix:
+        os: [macos-13]
+    runs-on: ${{ matrix.os }}
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+      - name: Build wheels
+        uses: pypa/cibuildwheel@v3.2.1
+        env:
+          CIBW_BEFORE_ALL: |
+              bash ./tools/build_talib_macos.sh
+          CIBW_TEST_COMMAND: >
+            cd .. &&
+            pytest -k "not RSI and not threading" {project}/tests
+          CIBW_ARCHS_MACOS: x86_64
+          CIBW_ENVIRONMENT_MACOS : >
+            TA_LIBRARY_PATH="ta-lib-install/lib"
+            TA_INCLUDE_PATH="ta-lib-install/include"
+            PIP_NO_BUILD_ISOLATION=false
+          CIBW_REPAIR_WHEEL_COMMAND_MACOS: |
+            export MACOSX_DEPLOYMENT_TARGET=13.7
+            export DYLD_LIBRARY_PATH="/Users/runner/work/${{ github.event.repository.name }}/${{ github.event.repository.name }}/ta-lib-install/lib:$DYLD_LIBRARY_PATH"
+            delocate-wheel --require-archs {delocate_archs} -w {dest_dir} -v {wheel}
+      - name: Upload wheels
+        uses: actions/upload-artifact@v4
+        with:
+          path: ./wheelhouse/*.whl
+          name: "ta_lib-${{ github.ref_name }}-macos_x86_64"
+  build_macos_arm64:
+    name: Build MacOS arm64 wheels
+    strategy:
+      matrix:
+        os: [macos-14]
+    runs-on: ${{ matrix.os }}
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+      - name: Build wheels
+        uses: pypa/cibuildwheel@v3.2.1
+        env:
+          CIBW_BEFORE_ALL: |
+              bash ./tools/build_talib_macos.sh
+          CIBW_TEST_COMMAND: >
+            cd .. &&
+            pytest -k "not RSI and not threading" {project}/tests
+          CIBW_ARCHS_MACOS: arm64
+          CIBW_ENVIRONMENT_MACOS : >
+            TA_LIBRARY_PATH="ta-lib-install/lib"
+            TA_INCLUDE_PATH="ta-lib-install/include"
+            PIP_NO_BUILD_ISOLATION=false
+          CIBW_REPAIR_WHEEL_COMMAND_MACOS: |
+            export MACOSX_DEPLOYMENT_TARGET=14.0
+            export DYLD_LIBRARY_PATH="/Users/runner/work/${{ github.event.repository.name }}/${{ github.event.repository.name }}/ta-lib-install/lib:$DYLD_LIBRARY_PATH"
+            delocate-wheel --require-archs {delocate_archs} -w {dest_dir} -v {wheel}
+      - name: Upload wheels
+        uses: actions/upload-artifact@v4
+        with:
+          path: ./wheelhouse/*.whl
+          name: "ta_lib-${{ github.ref_name }}-macos_arm64"
diff --git a/.travis.yml b/.travis.yml
deleted file mode 100644
index 3902618cc..000000000
--- a/.travis.yml
+++ /dev/null
@@ -1,28 +0,0 @@
----
-language: python
-python:
-  - "2.7"
-  - "3.4"
-  - "3.5"
-  - "3.6"
-os:
-  - linux
-env:
-  global:
-    - DEPS_DIR=$HOME/dependencies
-  matrix:
-    - WITH_TA_LIBRARY=yes
-      TA_INCLUDE_PATH=$DEPS_DIR/include
-      LD_LIBRARY_PATH=$DEPS_DIR/lib
-      TA_LIBRARY_PATH=$DEPS_DIR/lib
-cache:
-  directories:
-    - $DEPS_DIR
-install:
-  - pip install --upgrade pip wheel
-  - pip install -r requirements_test.txt
-  - if [ $WITH_TA_LIBRARY = "yes" ]; then
-      ./tools/build_talib_from_source.bash $DEPS_DIR;
-    fi
-script:
-  - make test
diff --git a/CHANGELOG b/CHANGELOG
index 0959b6a7a..933377fe8 100644
--- a/CHANGELOG
+++ b/CHANGELOG
@@ -1,10 +1,254 @@
+0.6.9
+=====
+
+- [FIX]: Adding ACCBANDS, AVGDEV, IMI to get_func_groups()
+
+- [FIX]: Adding ACCBANDS, AVGDEV, IMI to docs pages
+
+0.6.8
+=====
+
+- [FIX]: Remove accidental cython dependency.
+
+- [NEW]: Upgrade to Cython 3.1.5
+
+- [NEW]: Release binaries for Python 3.14
+
+0.6.7
+=====
+
+- [NEW]: Upgrade to Cython 3.1.3
+
+- [FIX]: Include .pxd files in the source .tar.gz
+
+- [FIX]: Don't require pip, it's not needed
+
+- [FIX]: Add back some import compat for backtrader
+
+0.6.6
+=====
+
+- [FIX]: Silence project.license warnings when building.
+
+- [FIX]: Fix regression in abstract function parameters not coercing integers
+
+0.6.5
+=====
+
+- [FIX]: Support PEP-517 style installation
+
+- [NEW]: Upgrade to Cython 3.1.2
+
+- [NEW]: Build binary wheels for Windows, macOS, and Linux.
+
+0.6.4
+=====
+
+- [FIX]: Adding typed for ACCBANDS, AVGDEV, IMI, and stream_* functions
+
+- [FIX]: Fix for numpy 2.3.0, which removed the npy_1_7_deprecated_api
+
+0.6.3
+=====
+
+- [FIX]: Fix issue building against numpy2
+
+0.6.2
+=====
+
+- [NEW]: Adding indicators ACCBANDS, AVGDEV, IMI
+
+0.6.1
+=====
+
+- [FIX]: Build properly against TA-Lib 0.6.2 and newer on Windows.
+
+0.6.0
+=====
+
+- [FIX]: Make sure this wrapper works with TA-Lib 0.6.1 and newer releases.
+
+0.5.5
+=====
+
+- [FIX]: Fix for numpy 2.3.0, which removed the npy_1_7_deprecated_api
+
+0.5.4
+=====
+
+- [FIX]: Fix lib name on windows.
+
+0.5.3
+=====
+
+- [BUG]: Make this release only support TA-Lib 0.4.0.
+
+0.5.2
+=====
+
+- [NEW]: Provide py typed information for C wrapper
+
+- [FIX]: Make sure this wrapper works with TA-Lib 0.6.1
+
+0.5.1
+=====
+
+- [FIX]: include cython *.pxi files in the source tar.gz
+
+0.5.0
+=====
+
+- [NEW]: Upgrade to Numpy 2.0
+
+0.4.38
+======
+
+- [FIX]: Fix lib name on windows.
+
+0.4.37
+======
+
+- [FIX]: Make sure to pin numpy<2 in the setup.py.
+
+0.4.36
+======
+
+- [BUG]: Make this release only support TA-Lib 0.4.0
+
+0.4.35
+======
+
+- [FIX]: Make sure this wrapper works with TA-Lib 0.6.1
+
+0.4.34
+=====
+
+- [FIX]: include cython *.pxi files in the source tar.gz
+
+0.4.33
+======
+
+- [NEW]: Upgrade to Cython 3.0.11
+
+- [FIX]: Fix import of ``pandas`` and ``polars`` to throw underlying import errors
+
+0.4.32
+======
+
+- [FIX]: Make sure numpy<2 is in the requirements.txt
+
+0.4.31
+======
+
+- [FIX]: Fix build issue with numpy2 released by requiring numpy<2.0.0 for now
+
+0.4.30
+======
+
+- [FIX]: Fix the C library imports to work again on Windows, oops.
+
+0.4.29
+======
+
+- [NEW]: Upgrade to Cython 3.0.10
+
+- [FIX]: Make TA_INCLUDE_PATH and TA_LIBRARY_PATH override default search list
+
+- [FIX]: Silent some compiler warnings about const pointers
+
+0.4.28
+======
+
+- [NEW]: Upgrade to Cython 3.0.0
+
+- [FIX]: Use embedsignature to enable code completions?
+
+0.4.27
+======
+
+- [NEW]: Upgrade to Cython 0.29.36
+
+- [FIX]: Fix abstract info to keep values doubles when they are (e.g., nbdevup, nvdevdn)
+
+- [FIX]: Don't throw exceptions when inputs are all NaN
+
+0.4.26
+======
+
+- [NEW]: Upgrade to Cython 0.29.34
+
+- [NEW]: Moved to https://github.com/ta-lib/ta-lib-python
+
+- [FIX]: Fix deprecation warning for polars.DataFrame(columns=[...])
+
+0.4.25
+======
+
+- [NEW]: Upgrade to Cython 0.29.32
+
+- [FIX]: Allow Abstract API to be safely used with multithreading
+
+0.4.24
+======
+
+- [FIX]: runtime_lib_dirs preventing install on Windows
+
+0.4.23
+======
+
+- [NEW]: Upgrade to Cython 0.29.25
+
+- [NEW]: Allow TA_INCLUDE_PATH and TA_LIBRARY_PATH to work on Windows.
+
+- [FIX]: Remove pyproject.toml which was preventing some installs.
+
+0.4.22
+======
+
+- [NEW]: Upgrade to Cython 0.29.24
+
+- [NEW]: Support polars.Series in Function API
+
+- [NEW]: Support polars.Series in Streaming API
+
+- [NEW]: Support polars.DataFrame in Abstract API
+
+- [NEW]: Switch tests to pytest from nose (no longer supported).
+
+0.4.21
+======
+
+- [FIX]: Fixed {MIN/MAX/MINMAX}INDEX functions to return correct indices.
+
+0.4.20
+======
+
+- [NEW]: Upgrade to Cython 0.29.23
+
+- [FIX]: Fix Homebrew directory on Apple M1 devices
+
+0.4.19
+======
+
+- [NEW]: Upgrade to Cython 0.29.20
+
+- [NEW]: from talib import * (imports all func and stream)
+
+- [FIX]: missing method signatures in PyCharm
+
 0.4.18
 ======
 
-- [NEW]: Upgrade to Cython 0.28.1
+- [NEW]: Upgrade to Cython 0.29.17
+
+- [NEW]: Support TA_SetCompatibility
 
 - [NEW]: Reduce size of generated C file and memory requirements to compile it.
 
+- [FIX]: Fixed caching input price series in Abstract API
+
+- [NEW]: Support pandas.Series in Streaming API
+
 0.4.17
 ======
 
diff --git a/CITATION.cff b/CITATION.cff
new file mode 100644
index 000000000..3cd0641f2
--- /dev/null
+++ b/CITATION.cff
@@ -0,0 +1,11 @@
+cff-version: 1.2.0
+message: "If you use this software, please cite it as below."
+title: ta-lib-python
+version: 0.6.5
+date-released: 2025-08-07
+url: "https://github.com/ta-lib/ta-lib-python"
+type: software
+authors:
+  - given-names: John
+    family-names: Benediktsson
+    email: mrjbq7@gmail.com
diff --git a/DEVELOPMENT b/DEVELOPMENT
index fd29fec0e..571a48a2c 100644
--- a/DEVELOPMENT
+++ b/DEVELOPMENT
@@ -1,11 +1,13 @@
 To get started developing on talib, clone the latest code from git and
 install:
 
-$ git clone git://github.com/mrjbq7/ta-lib.git
-$ cd ta-lib
+```
+$ git clone git://github.com/ta-lib/ta-lib-python.git
+$ cd ta-lib-python
 # you can run "git pull" here (no quotes) to update the sources in the future
 $ make build
 $ [sudo] make install
+```
 
 Here's the full list of make commands (see the Makefile file):
 
@@ -43,21 +45,4 @@ tools/generate_func.py,generate_stream.py
   about all functions from the C headers of the installed TA-Lib.
 
 If you are interested in developing new indicator functions or whatnot on
-the underlying TA-Lib, you must install TA-Lib from svn. Here's how (Linux
-tested):
-
-```
-$ cd ~/dev
-$ svn checkout svn://svn.code.sf.net/p/ta-lib/code/trunk@1545 ta-lib-code
-# later revisions break building ta_regtest (but claim to add support for VS2012)
-$ cd ta-lib-code/ta-lib/c/make/gen_make
-$ perl ./gen_make.pl
-$ # cd ta-lib-code/ta-lib/c/make/cmr && make --> compile the code (no install)
-$ cd ~/dev/ta-lib-code/tools
-# Depending upon your platform you may need to make minor changes to this script:
-$ perl ./release_unix.pl -version 0.4.X -source ../ta-lib/c
-$ cd ~/ta-lib-0.4.X-work/dist
-# the installable source package will be here, and if you wanted, the deb/rpm
-# packages then see http://ta-lib.org/d_misc/how-to_function.html and the
-# README/comments in the src
-```
+the underlying TA-Lib, you must install TA-Lib from git.
diff --git a/Dockerfile b/Dockerfile
new file mode 100644
index 000000000..68af94a3b
--- /dev/null
+++ b/Dockerfile
@@ -0,0 +1,52 @@
+# Dockerfile for TA-Lib. To build:
+#
+#    docker build --rm -t talib .
+#
+# To run:
+#
+#    docker run --rm -it talib bash
+#
+
+ARG PYTHON_VERSION="3.7"
+
+FROM python:$PYTHON_VERSION as builder
+
+ENV TA_PREFIX="/opt/ta-lib-core"
+ENV TA_LIBRARY_PATH="$TA_PREFIX/lib" \
+    TA_INCLUDE_PATH="$TA_PREFIX/include"
+
+WORKDIR /src/ta-lib-core
+RUN apt-get update && apt-get install -y \
+        gfortran \
+        libfreetype6-dev \
+        libhdf5-dev \
+        liblapack-dev \
+        libopenblas-dev \
+        libpng-dev \
+    && rm -rf /var/lib/apt/lists/* \
+    && curl -fsSL http://prdownloads.sourceforge.net/ta-lib/ta-lib-0.4.0-src.tar.gz \
+    | tar xvz --strip-components 1 \
+    && ./configure --prefix="$TA_PREFIX" \
+    && make \
+    && make install
+
+WORKDIR /src/ta-lib-python
+COPY . .
+RUN python -m pip install -e . \
+    && python -c 'import numpy, talib; close = numpy.random.random(100); output = talib.SMA(close); print(output)' \
+    && python -m pip wheel --wheel-dir wheels .
+
+ARG RUN_TESTS="1"
+RUN if [ "$RUN_TESTS" -ne "0" ]; then \
+        python -m pip install -r requirements_test.txt \
+        && pytest . ; \
+    else \
+        echo "Skipping tests\n" ; \
+    fi
+
+# Build final image.
+FROM python:$PYTHON_VERSION-slim
+COPY --from=builder /src/ta-lib-python/wheels /opt/ta-lib-python/wheels
+COPY --from=builder /opt/ta-lib-core /opt/ta-lib-core
+RUN python -m pip install --no-cache-dir /opt/ta-lib-python/wheels/*.whl \
+    && python -c 'import numpy, talib; close = numpy.random.random(100); output = talib.SMA(close); print(output)'
diff --git a/LICENSE b/LICENSE
index 721ed8541..bac52bae9 100644
--- a/LICENSE
+++ b/LICENSE
@@ -1,3 +1,5 @@
+# BSD 2-Clause License
+
 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions are met:
 
@@ -8,14 +10,13 @@ modification, are permitted provided that the following conditions are met:
    this list of conditions and the following disclaimer in the documentation
    and/or other materials provided with the distribution.
 
-THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
-INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
-FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
-DEVELOPERS AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
-OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
-WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
-OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
-ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/MANIFEST.in b/MANIFEST.in
index 16f2efc0e..44b36dba8 100644
--- a/MANIFEST.in
+++ b/MANIFEST.in
@@ -3,3 +3,6 @@ include COPYRIGHT
 include README.md
 include talib/*.c
 include talib/*.pyx
+include talib/*.pxd
+include talib/*.pxi
+include tests/*.py
diff --git a/Makefile b/Makefile
index 9e8d4c4e0..d86ef416a 100644
--- a/Makefile
+++ b/Makefile
@@ -1,30 +1,33 @@
 .PHONY: build
 
 build:
-	python setup.py build_ext --inplace
+	python3 -m pip install --use-pep517 -e .
 
 install:
-	python setup.py install
+	python3 -m pip install --use-pep517 .
 
 talib/_func.pxi: tools/generate_func.py
-	python tools/generate_func.py > talib/_func.pxi
+	python3 tools/generate_func.py > talib/_func.pxi
 
 talib/_stream.pxi: tools/generate_stream.py
-	python tools/generate_stream.py > talib/_stream.pxi
+	python3 tools/generate_stream.py > talib/_stream.pxi
 
 generate: talib/_func.pxi talib/_stream.pxi
 
 cython:
-	cython --directive emit_code_comments=False talib/_ta_lib.pyx
+	cython talib/_ta_lib.pyx
+
+annotate:
+	cython -a talib/_ta_lib.pyx
 
 clean:
 	rm -rf build talib/_ta_lib.so talib/*.pyc
 
 perf:
-	python tools/perf_talib.py
+	python3 tools/perf_talib.py
 
 test: build
-	LD_LIBRARY_PATH=/usr/local/lib:${LD_LIBRARY_PATH} nosetests
+	pytest tests/
 
 sdist:
-	python setup.py sdist --formats=gztar,zip
+	python3 -m build --sdist
diff --git a/README.md b/README.md
index 06e7d3cac..16ade8deb 100644
--- a/README.md
+++ b/README.md
@@ -1,13 +1,19 @@
-# TA-Lib
+# TA-Lib 📈
 
-[![](https://api.travis-ci.org/mrjbq7/ta-lib.svg)](https://travis-ci.org/mrjbq7/ta-lib)
+<!-- Badges -->
+![Tests](https://github.com/ta-lib/ta-lib-python/actions/workflows/tests.yml/badge.svg)
+[![Release](https://img.shields.io/github/v/release/ta-lib/ta-lib-python?label=Release)](https://github.com/ta-lib/ta-lib-python/releases)
+[![PyPI](https://img.shields.io/pypi/v/TA-Lib?label=PyPI)](https://pypi.org/project/TA-Lib/)
+[![Wheels](https://img.shields.io/pypi/wheel/TA-Lib?label=Wheels)](https://pypi.org/project/TA-Lib/#files)
+[![Python Versions](https://img.shields.io/pypi/pyversions/TA-Lib?label=Python)](https://pypi.org/project/TA-Lib/)
+[![License](https://img.shields.io/badge/License-BSD%202--Clause-blue.svg)](https://opensource.org/licenses/BSD-2-Clause)
 
 This is a Python wrapper for [TA-LIB](http://ta-lib.org) based on Cython
 instead of SWIG. From the homepage:
 
 > TA-Lib is widely used by trading software developers requiring to perform
 > technical analysis of financial market data.
-
+>
 > * Includes 150+ indicators such as ADX, MACD, RSI, Stochastic, Bollinger
 >   Bands, etc.
 > * Candlestick pattern recognition
@@ -15,58 +21,197 @@ instead of SWIG. From the homepage:
 
 The original Python bindings included with TA-Lib use
 [SWIG](http://swig.org) which unfortunately are difficult to install and
-aren't as efficient as they could be. Therefore this project uses Cython and
-Numpy to efficiently and cleanly bind to TA-Lib -- producing results 2-4
-times faster than the SWIG interface.
+aren't as efficient as they could be. Therefore this project uses
+[Cython](https://cython.org) and [Numpy](https://numpy.org) to efficiently
+and cleanly bind to TA-Lib - producing results 2-4 times faster than the
+SWIG interface.
+
+In addition, this project also supports the use of the
+[Polars](https://www.pola.rs) and [Pandas](https://pandas.pydata.org)
+libraries.
+
+## Versions 🗂️
+
+The upstream TA-Lib C library released version 0.6.1 and changed the library
+name to `-lta-lib` from `-lta_lib`. After trying to support both via
+autodetect and having some issues, we have decided to currently support three
+feature branches:
 
-## Installation
+* `ta-lib-python` 0.4.x (supports `ta-lib` 0.4.x and `numpy` 1)
+* `ta-lib-python` 0.5.x (supports `ta-lib` 0.4.x and `numpy` 2)
+* `ta-lib-python` 0.6.x (supports `ta-lib` 0.6.x and `numpy` 2)
+
+## Installation 💾
 
 You can install from PyPI:
 
+```shell
+python -m pip install TA-Lib
 ```
-$ pip install TA-Lib
+
+Or checkout the sources and run `setup.py` yourself:
+
+```shell
+python setup.py install
 ```
 
-Or checkout the sources and run ``setup.py`` yourself:
+It also appears possible to install via [Conda Forge](https://anaconda.org/conda-forge/ta-lib):
 
+```shell
+conda install -c conda-forge ta-lib
 ```
-$ python setup.py install
+
+```shell
+conda install -c conda-forge ta-lib
 ```
 
-### Troubleshooting
+### Dependencies 🧩
 
-If you get a warning that looks like this:
+To use TA-Lib for python, you need to have the [TA-Lib](http://ta-lib.org)
+already installed. You should probably follow their [installation
+directions](https://ta-lib.org/install/) for your platform, but some
+suggestions are included below for reference.
+
+> Some Conda Forge users have reported success installing the underlying TA-Lib C
+> library using [the libta-lib package](https://anaconda.org/conda-forge/libta-lib):
+>
+> ``$ conda install -c conda-forge libta-lib``
+
+#### Mac OS X
+
+You can simply install using Homebrew:
+
+```shell
+brew install ta-lib
+```
+
+If you are using Apple Silicon, such as the M1 processors, and building mixed
+architecture Homebrew projects, you might want to make sure it's being built
+for your architecture:
+
+```shell
+arch -arm64 brew install ta-lib
+```
+
+And perhaps you can set these before installing with `pip`:
+
+```shell
+export TA_INCLUDE_PATH="$(brew --prefix ta-lib)/include"
+export TA_LIBRARY_PATH="$(brew --prefix ta-lib)/lib"
+```
+
+You might also find this helpful, particularly if you have tried several
+different installations without success:
+
+```shell
+your-arm64-python -m pip install --no-cache-dir ta-lib
+```
+
+#### Windows
+
+For 64-bit Windows, the easiest way is to get the *executable installer*:
+
+1. Download [ta-lib-0.6.4-windows-x86_64.msi](https://github.com/ta-lib/ta-lib/releases/download/v0.6.4/ta-lib-0.6.4-windows-x86_64.msi).
+2. Run the Installer or run `msiexec` [from the command-line](https://learn.microsoft.com/en-us/windows/win32/msi/standard-installer-command-line-options).
+
+Alternatively, if you prefer to get the libraries without installing, or
+would like to use the 32-bit version:
+
+* Intel/AMD 64-bit [ta-lib-0.6.4-windows-x86_64.zip](https://github.com/ta-lib/ta-lib/releases/download/v0.6.4/ta-lib-0.6.4-windows-x86_64.zip)
+* Intel/AMD 32-bit [ta-lib-0.6.4-windows-x86_32.zip](https://github.com/ta-lib/ta-lib/releases/download/v0.6.4/ta-lib-0.6.4-windows-x86_32.zip)
+
+#### Linux
+
+Download
+[ta-lib-0.6.4-src.tar.gz](https://github.com/ta-lib/ta-lib/releases/download/v0.6.4/ta-lib-0.6.4-src.tar.gz)
+and:
 
+```shell
+tar -xzf ta-lib-0.6.4-src.tar.gz
+cd ta-lib-0.6.4/
+./configure --prefix=/usr
+make
+sudo make install
 ```
+
+> If you build `TA-Lib` using `make -jX` it will fail but that's OK!
+> Simply rerun ``make -jX`` followed by ``[sudo] make install``.
+
+Note: if your directory path includes spaces, the installation will probably
+fail with ``No such file or directory`` errors.
+
+### Wheels ⚙️
+
+For convenience, and starting with version 0.6.5, we now build binary wheels
+for different operating systems, architectures, and Python versions using
+GitHub Actions which include the underlying TA-Lib C library and are easy to
+install.
+
+Supported platforms:
+
+* Linux
+  * x86_64
+  * arm64
+* macOS
+  * x86_64
+  * arm64
+* Windows
+  * x86_64
+  * x86
+  * arm64
+
+Supported Python versions:
+
+* 3.9
+* 3.10
+* 3.11
+* 3.12
+* 3.13
+
+In the event that your operating system, architecture, or Python version are
+not available as a binary wheel, it is fairly easy to install from source
+using the instructions above.
+
+### Troubleshooting 🛠️
+
+If you get a warning that looks like this:
+
+```shell
 setup.py:79: UserWarning: Cannot find ta-lib library, installation may fail.
 warnings.warn('Cannot find ta-lib library, installation may fail.')
 ```
 
-This typically means ``setup.py`` can't find the underlying ``TA-Lib``
+This typically means `setup.py` can't find the underlying `TA-Lib`
 library, a dependency which needs to be installed.
 
-If you installed the underlying ``TA-Lib`` library with a custom prefix
-(e.g., with ``./configure --prefix=$PREFIX``), then when you go to install
+---
+
+If you installed the underlying `TA-Lib` library with a custom prefix
+(e.g., with `./configure --prefix=$PREFIX`), then when you go to install
 this python wrapper you can specify additional search paths to find the
-library and include files for the underyling ``TA-Lib`` library using the
-``TA_LIBRARY_PATH`` and ``TA_INCLUDE_PATH`` environment variables:
+library and include files for the underlying `TA-Lib` library using the
+`TA_LIBRARY_PATH` and `TA_INCLUDE_PATH` environment variables:
 
-```sh
-$ export TA_LIBRARY_PATH=$PREFIX/lib
-$ export TA_INCLUDE_PATH=$PREFIX/include
-$ python setup.py install # or pip install ta-lib
+```shell
+export TA_LIBRARY_PATH=$PREFIX/lib
+export TA_INCLUDE_PATH=$PREFIX/include
+python setup.py install # or pip install ta-lib
 ```
 
+---
+
 Sometimes installation will produce build errors like this:
 
-```
-func.c:256:28: fatal error: ta-lib/ta_libc.h: No such file or directory
+```shell
+talib/_ta_lib.c:601:10: fatal error: ta-lib/ta_defs.h: No such file or directory
+  601 | #include "ta-lib/ta_defs.h"
+      |          ^~~~~~~~~~~~~~~~~~
 compilation terminated.
 ```
 
 or:
 
-```
+```shell
 common.obj : error LNK2001: unresolved external symbol TA_SetUnstablePeriod
 common.obj : error LNK2001: unresolved external symbol TA_Shutdown
 common.obj : error LNK2001: unresolved external symbol TA_Initialize
@@ -74,14 +219,16 @@ common.obj : error LNK2001: unresolved external symbol TA_GetUnstablePeriod
 common.obj : error LNK2001: unresolved external symbol TA_GetVersionString
 ```
 
-This typically means that it can't find the underlying ``TA-Lib`` library, a
+This typically means that it can't find the underlying `TA-Lib` library, a
 dependency which needs to be installed.  On Windows, this could be caused by
-installing the 32-bit binary distribution of the underlying ``TA-Lib`` library,
+installing the 32-bit binary distribution of the underlying `TA-Lib` library,
 but trying to use it with 64-bit Python.
 
+---
+
 Sometimes installation will fail with errors like this:
 
-```
+```shell
 talib/common.c:8:22: fatal error: pyconfig.h: No such file or directory
  #include "pyconfig.h"
                       ^
@@ -92,77 +239,160 @@ error: command 'x86_64-linux-gnu-gcc' failed with exit status 1
 This typically means that you need the Python headers, and should run
 something like:
 
-```
-$ sudo apt-get install python3-dev
+```shell
+sudo apt-get install python3-dev
 ```
 
-Sometimes building the underlying ``TA-Lib`` library has errors running
-``make`` that look like this:
+---
 
-```
+Sometimes building the underlying `TA-Lib` library has errors running
+`make` that look like this:
+
+```shell
 ../libtool: line 1717: cd: .libs/libta_lib.lax/libta_abstract.a: No such file or directory
 make[2]: *** [libta_lib.la] Error 1
 make[1]: *** [all-recursive] Error 1
 make: *** [all-recursive] Error 1
 ```
 
-This might mean that the directory path to the underlying ``TA-Lib`` library
+This might mean that the directory path to the underlying `TA-Lib` library
 has spaces in the directory names.  Try putting it in a path that does not have
 any spaces and trying again.
 
+---
 
-### Dependencies
+Sometimes you might get this error running `setup.py`:
 
-To use TA-Lib for python, you need to have the
-[TA-Lib](http://ta-lib.org/hdr_dw.html) already installed. You should
-probably follow their installation directions for your platform, but some
-suggestions are included below for reference.
+```shell
+/usr/include/limits.h:26:10: fatal error: bits/libc-header-start.h: No such file or directory
+#include <bits/libc-header-start.h>
+         ^~~~~~~~~~~~~~~~~~~~~~~~~~
+```
+
+This is likely an issue with trying to compile for 32-bit platform but
+without the appropriate headers.  You might find some success looking at the
+first answer to [this question](https://stackoverflow.com/questions/54082459/fatal-error-bits-libc-header-start-h-no-such-file-or-directory-while-compili).
+
+---
+
+If you get an error on macOS like this:
+
+```shell
+code signature in <141BC883-189B-322C-AE90-CBF6B5206F67>
+'python3.9/site-packages/talib/_ta_lib.cpython-39-darwin.so' not valid for
+use in process: Trying to load an unsigned library)
+```
+
+You might look at [this question](https://stackoverflow.com/questions/69610572/how-can-i-solve-the-below-error-while-importing-nltk-package)
+and use ``xcrun codesign`` to fix it.
+
+---
 
-##### Mac OS X
+If you wonder why `STOCHRSI` gives you different results than you expect,
+probably you want `STOCH` applied to `RSI`, which is a little different
+than the `STOCHRSI` which is `STOCHF` applied to `RSI`:
 
+```python
+>>> import talib
+>>> import numpy as np
+>>> c = np.random.randn(100)
+
+# this is the library function
+>>> k, d = talib.STOCHRSI(c)
+
+# this produces the same result, calling STOCHF
+>>> rsi = talib.RSI(c)
+>>> k, d = talib.STOCHF(rsi, rsi, rsi)
+
+# you might want this instead, calling STOCH
+>>> rsi = talib.RSI(c)
+>>> k, d = talib.STOCH(rsi, rsi, rsi)
 ```
-$ brew install ta-lib
+
+---
+
+If the build appears to hang, you might be running on a VM with not enough memory - try 1 GB or 2 GB.
+
+It has also been reported that using a swapfile could help, for example:
+
+```shell
+sudo fallocate -l 1G /swapfile
+sudo chmod 600 /swapfile
+sudo mkswap /swapfile
+sudo swapon /swapfile
 ```
 
-##### Windows
+---
 
-Download [ta-lib-0.4.0-msvc.zip](http://prdownloads.sourceforge.net/ta-lib/ta-lib-0.4.0-msvc.zip)
-and unzip to ``C:\ta-lib``.
+If you get "permission denied" errors such as this, you might need to give
+your user access to the location where the underlying TA-Lib C library is
+installed -- or install it to a user-accessible location.
 
-> This is a 32-bit binary release.  If you want to use 64-bit Python, you will
-> need to build a 64-bit version of the library. Some unofficial (**and
-> unsupported**) instructions for building on 64-bit Windows 10, here for
-> reference:
->
-> 1. Download and Unzip ``ta-lib-0.4.0-msvc.zip``
-> 2. Move the Unzipped Folder ``ta-lib`` to ``C:\``
-> 3. Download and Install Visual Studio Community 2015
->    * Remember to Select ``[Visual C++]`` Feature
-> 4. Build TA-Lib Library
->    * From Windows Start Menu, Start ``[VS2015 x64 Native Tools Command
->      Prompt]``
->    * Move to ``C:\ta-lib\c\make\cdr\win32\msvc``
->    * Build the Library ``nmake``
+```shell
+talib/_ta_lib.c:747:28: fatal error: /usr/include/ta-lib/ta_defs.h: Permission denied
+ #include "ta-lib/ta-defs.h"
+                            ^
+compilation terminated
+error: command 'gcc' failed with exit status 1
+```
 
-You might also try these unofficial windows binaries for both 32-bit and
-64-bit:
+---
 
-https://www.lfd.uci.edu/~gohlke/pythonlibs/#ta-lib
+If you're having trouble compiling the underlying TA-Lib C library on ARM64,
+you might need to configure it with an explicit build type before running
+`make` and `make install`, for example:
 
-##### Linux
+```shell
+./configure --build=aarch64-unknown-linux-gnu
+```
 
-Download [ta-lib-0.4.0-src.tar.gz](http://prdownloads.sourceforge.net/ta-lib/ta-lib-0.4.0-src.tar.gz) and:
+This is caused by old `config.guess` file, so another way to solve this is
+to copy a newer version of config.guess into the underlying TA-Lib C library
+sources:
 
+```shell
+cp /usr/share/automake-1.16/config.guess /path/to/extracted/ta-lib/config.guess
 ```
-$ tar -xzf ta-lib-0.4.0-src.tar.gz
-$ cd ta-lib/
-$ ./configure --prefix=/usr
-$ make
-$ sudo make install
+
+And then re-run configure:
+
+```shell
+./configure
 ```
 
-> If you build ``TA-Lib`` using ``make -jX`` it will fail but that's OK!
-> Simply rerun ``make -jX`` followed by ``[sudo] make install``.
+---
+
+If you're having trouble using [PyInstaller](https://pyinstaller.org) and
+get an error that looks like this:
+
+```shell
+...site-packages\PyInstaller\loader\pyimod03_importers.py", line 493, in exec_module
+    exec(bytecode, module.__dict__)
+  File "talib\__init__.py", line 72, in <module>
+ModuleNotFoundError: No module named 'talib.stream'
+```
+
+Then, perhaps you can use the `--hidden-import` argument to fix this:
+
+```shell
+pyinstaller --hidden-import talib.stream "replaceToYourFileName.py"
+```
+
+---
+
+If you want to use `numpy<2`, then you should use `ta-lib<0.5`.
+
+If you want to use `numpy>=2`, then you should use `ta-lib>=0.5`.
+
+---
+
+If you have trouble getting the code autocompletions to work in Visual
+Studio Code, a suggestion was made to look for the `Python` extension
+settings, and an option for `Language Server`, and change it from
+`Default` (which means `Pylance if it is installed, Jedi otherwise`), to
+manually set `Jedi` and the completions should work. It is possible that
+you might need to [install it manually](https://github.com/pappasam/jedi-language-server) for this to
+work.
 
 ## Function API
 
@@ -172,18 +402,18 @@ exposed TA-Lib indicators.
 Each function returns an output array and have default values for their
 parameters, unless specified as keyword arguments. Typically, these functions
 will have an initial "lookback" period (a required number of observations
-before an output is generated) set to ``NaN``.
+before an output is generated) set to `NaN`.
 
-For convenience, the Function API supports both ``numpy.ndarray`` and
-``pandas.Series`` inputs.
+For convenience, the Function API supports both `numpy.ndarray` and
+`pandas.Series` and `polars.Series` inputs.
 
 All of the following examples use the Function API:
 
 ```python
-import numpy
+import numpy as np
 import talib
 
-close = numpy.random.random(100)
+close = np.random.random(100)
 ```
 
 Calculate a simple moving average of the close prices:
@@ -206,15 +436,45 @@ Calculating momentum of the close prices, with a time period of 5:
 output = talib.MOM(close, timeperiod=5)
 ```
 
+### NaN's
+
+The underlying TA-Lib C library handles NaN's in a sometimes surprising manner
+by typically propagating NaN's to the end of the output, for example:
+
+```python
+>>> c = np.array([1.0, 2.0, 3.0, np.nan, 4.0, 5.0, 6.0])
+
+>>> talib.SMA(c, 3)
+array([nan, nan,  2., nan, nan, nan, nan])
+```
+
+You can compare that to a Pandas rolling mean, where their approach is to
+output NaN until enough "lookback" values are observed to generate new outputs:
+
+```python
+>>> c = pandas.Series([1.0, 2.0, 3.0, np.nan, 4.0, 5.0, 6.0])
+
+>>> c.rolling(3).mean()
+0    NaN
+1    NaN
+2    2.0
+3    NaN
+4    NaN
+5    NaN
+6    5.0
+dtype: float64
+```
+
 ## Abstract API
 
 If you're already familiar with using the function API, you should feel right
 at home using the Abstract API.
 
 Every function takes a collection of named inputs, either a ``dict`` of
-``numpy.ndarray`` or ``pandas.Series``, or a ``pandas.DataFrame``. If a
-``pandas.DataFrame`` is provided, the output is returned as a
-``pandas.DataFrame`` with named output columns.
+``numpy.ndarray`` or ``pandas.Series`` or ``polars.Series``, or a
+``pandas.DataFrame`` or ``polars.DataFrame``. If a ``pandas.DataFrame`` or
+``polars.DataFrame`` is provided, the output is returned as the same type
+with named output columns.
 
 For example, inputs could be provided for the typical "OHLCV" data:
 
@@ -255,7 +515,7 @@ output = SMA(inputs, timeperiod=25)
 output = SMA(inputs, timeperiod=25, price='open')
 
 # uses close prices (default)
-upper, middle, lower = BBANDS(inputs, 20, 2, 2)
+upper, middle, lower = BBANDS(inputs, 20, 2.0, 2.0)
 
 # uses high, low, close (default)
 slowk, slowd = STOCH(inputs, 5, 3, 0, 3, 0) # uses high, low, close by default
@@ -264,23 +524,50 @@ slowk, slowd = STOCH(inputs, 5, 3, 0, 3, 0) # uses high, low, close by default
 slowk, slowd = STOCH(inputs, 5, 3, 0, 3, 0, prices=['high', 'low', 'open'])
 ```
 
-## Supported Indicators and Functions
+## Streaming API
+
+An experimental Streaming API was added that allows users to compute the latest
+value of an indicator.  This can be faster than using the Function API, for
+example in an application that receives streaming data, and wants to know just
+the most recent updated indicator value.
+
+```python
+import talib
+from talib import stream
+
+close = np.random.random(100)
+
+# the Function API
+output = talib.SMA(close)
+
+# the Streaming API
+latest = stream.SMA(close)
+
+# the latest value is the same as the last output value
+assert (output[-1] - latest) < 0.00001
+```
+
+## Supported Indicators and Functions 📋
 
-We can show all the TA functions supported by TA-Lib, either as a ``list`` or
-as a ``dict`` sorted by group (e.g. "Overlap Studies", "Momentum Indicators",
+We can show all the TA functions supported by TA-Lib, either as a `list` or
+as a `dict` sorted by group (e.g. "Overlap Studies", "Momentum Indicators",
 etc):
 
 ```python
 import talib
 
 # list of functions
-print talib.get_functions()
+for name in talib.get_functions():
+    print(name)
 
 # dict of functions by group
-print talib.get_function_groups()
+for group, names in talib.get_function_groups().items():
+    print(group)
+    for name in names:
+        print(f"  {name}")
 ```
 
-### Indicator Groups
+### Indicator Groups 🏷️
 
 * Overlap Studies
 * Momentum Indicators
@@ -290,8 +577,9 @@ print talib.get_function_groups()
 * Cycle Indicators
 * Pattern Recognition
 
-##### Overlap Studies
-```
+#### Overlap Studies
+
+```text
 BBANDS               Bollinger Bands
 DEMA                 Double Exponential Moving Average
 EMA                  Exponential Moving Average
@@ -311,8 +599,9 @@ TRIMA                Triangular Moving Average
 WMA                  Weighted Moving Average
 ```
 
-##### Momentum Indicators
-```
+#### Momentum Indicators
+
+```text
 ADX                  Average Directional Movement Index
 ADXR                 Average Directional Movement Index Rating
 APO                  Absolute Price Oscillator
@@ -345,15 +634,17 @@ ULTOSC               Ultimate Oscillator
 WILLR                Williams' %R
 ```
 
-##### Volume Indicators
-```
+#### Volume Indicators
+
+```text
 AD                   Chaikin A/D Line
 ADOSC                Chaikin A/D Oscillator
 OBV                  On Balance Volume
 ```
 
-##### Cycle Indicators
-```
+#### Cycle Indicators
+
+```text
 HT_DCPERIOD          Hilbert Transform - Dominant Cycle Period
 HT_DCPHASE           Hilbert Transform - Dominant Cycle Phase
 HT_PHASOR            Hilbert Transform - Phasor Components
@@ -361,23 +652,26 @@ HT_SINE              Hilbert Transform - SineWave
 HT_TRENDMODE         Hilbert Transform - Trend vs Cycle Mode
 ```
 
-##### Price Transform
-```
+#### Price Transform
+
+```text
 AVGPRICE             Average Price
 MEDPRICE             Median Price
 TYPPRICE             Typical Price
 WCLPRICE             Weighted Close Price
 ```
 
-##### Volatility Indicators
-```
+#### Volatility Indicators
+
+```text
 ATR                  Average True Range
 NATR                 Normalized Average True Range
 TRANGE               True Range
 ```
 
-##### Pattern Recognition
-```
+#### Pattern Recognition
+
+```text
 CDL2CROWS            Two Crows
 CDL3BLACKCROWS       Three Black Crows
 CDL3INSIDE           Three Inside Up/Down
@@ -440,3 +734,17 @@ CDLUNIQUE3RIVER      Unique 3 River
 CDLUPSIDEGAP2CROWS   Upside Gap Two Crows
 CDLXSIDEGAP3METHODS  Upside/Downside Gap Three Methods
 ```
+
+#### Statistic Functions
+
+```text
+BETA                 Beta
+CORREL               Pearson's Correlation Coefficient (r)
+LINEARREG            Linear Regression
+LINEARREG_ANGLE      Linear Regression Angle
+LINEARREG_INTERCEPT  Linear Regression Intercept
+LINEARREG_SLOPE      Linear Regression Slope
+STDDEV               Standard Deviation
+TSF                  Time Series Forecast
+VAR                  Variance
+```
diff --git a/docs/abstract.md b/docs/abstract.md
index ddebaff90..96a979967 100644
--- a/docs/abstract.md
+++ b/docs/abstract.md
@@ -28,11 +28,11 @@ From there, calling functions is basically the same as the function API:
 
 ```python
 from talib.abstract import *
-output = SMA(input_arrays, timeperiod=25) # calculate on close prices by default
-output = SMA(input_arrays, timeperiod=25, price='open') # calculate on opens
-upper, middle, lower = BBANDS(input_arrays, 20, 2, 2)
-slowk, slowd = STOCH(input_arrays, 5, 3, 0, 3, 0) # uses high, low, close by default
-slowk, slowd = STOCH(input_arrays, 5, 3, 0, 3, 0, prices=['high', 'low', 'open'])
+output = SMA(inputs, timeperiod=25) # calculate on close prices by default
+output = SMA(inputs, timeperiod=25, price='open') # calculate on opens
+upper, middle, lower = BBANDS(inputs, 20, 2, 2)
+slowk, slowd = STOCH(inputs, 5, 3, 0, 3, 0) # uses high, low, close by default
+slowk, slowd = STOCH(inputs, 5, 3, 0, 3, 0, prices=['high', 'low', 'open'])
 ```
 
 ## Advanced Usage
@@ -98,6 +98,6 @@ ma20 = SMA(20)
 ```
 
 For more details, take a look at the
-[code](https://github.com/mrjbq7/ta-lib/blob/master/talib/abstract.pyx#L46).
+[code](https://github.com/ta-lib/ta-lib-python/blob/master/talib/abstract.pyx#L46).
 
-[Documentation Index](doc_index.html)
+[Documentation Index](doc_index.md)
diff --git a/docs/doc_index.md b/docs/doc_index.md
index a48f46888..ae43f1cf6 100644
--- a/docs/doc_index.md
+++ b/docs/doc_index.md
@@ -1,16 +1,16 @@
 # Documentation
 
-* [Installation and Troubleshooting](install.html)
-* [Using the Function API](func.html)
-* [Using the Abstract API](abstract.html)
-* [All Functions](funcs.html)
-    * [Overlap Studies](func_groups/overlap_studies.html)
-    * [Momentum Indicators](func_groups/momentum_indicators.html)
-    * [Volume Indicators](func_groups/volume_indicators.html)
-    * [Volatility Indicators](func_groups/volatility_indicators.html)
-    * [Price Transform](func_groups/price_transform.html)
-    * [Cycle Indicators](func_groups/cycle_indicators.html)
-    * [Pattern Recognition](func_groups/pattern_recognition.html)
-    * [Statistic Functions](func_groups/statistic_functions.html)
-    * [Math Transform](func_groups/math_transform.html)
-    * [Math Operators](func_groups/math_operators.html)
+* [Installation and Troubleshooting](install.md)
+* [Using the Function API](func.md)
+* [Using the Abstract API](abstract.md)
+* [All Functions](funcs.md)
+    * [Overlap Studies](func_groups/overlap_studies.md)
+    * [Momentum Indicators](func_groups/momentum_indicators.md)
+    * [Volume Indicators](func_groups/volume_indicators.md)
+    * [Volatility Indicators](func_groups/volatility_indicators.md)
+    * [Price Transform](func_groups/price_transform.md)
+    * [Cycle Indicators](func_groups/cycle_indicators.md)
+    * [Pattern Recognition](func_groups/pattern_recognition.md)
+    * [Statistic Functions](func_groups/statistic_functions.md)
+    * [Math Transform](func_groups/math_transform.md)
+    * [Math Operators](func_groups/math_operators.md)
diff --git a/docs/func.md b/docs/func.md
index 459ad6a72..11d4efc09 100644
--- a/docs/func.md
+++ b/docs/func.md
@@ -39,16 +39,16 @@ output = talib.MOM(close, timeperiod=5)
 
 Documentation for all functions:
 
-* [Overlap Studies](func_groups/overlap_studies.html)
-* [Momentum Indicators](func_groups/momentum_indicators.html)
-* [Volume Indicators](func_groups/volume_indicators.html)
-* [Volatility Indicators](func_groups/volatility_indicators.html)
-* [Pattern Recognition](func_groups/pattern_recognition.html)
-* [Cycle Indicators](func_groups/cycle_indicators.html)
-* [Statistic Functions](func_groups/statistic_functions.html)
-* [Price Transform](func_groups/price_transform.html)
-* [Math Transform](func_groups/math_transform.html)
-* [Math Operators](func_groups/math_operators.html)
-
-[Documentation Index](doc_index.html)
-[FLOAT_RIGHTNext: Using the Abstract API](abstract.html)
+* [Overlap Studies](func_groups/overlap_studies.md)
+* [Momentum Indicators](func_groups/momentum_indicators.md)
+* [Volume Indicators](func_groups/volume_indicators.md)
+* [Volatility Indicators](func_groups/volatility_indicators.md)
+* [Pattern Recognition](func_groups/pattern_recognition.md)
+* [Cycle Indicators](func_groups/cycle_indicators.md)
+* [Statistic Functions](func_groups/statistic_functions.md)
+* [Price Transform](func_groups/price_transform.md)
+* [Math Transform](func_groups/math_transform.md)
+* [Math Operators](func_groups/math_operators.md)
+
+[Documentation Index](doc_index.md)
+[FLOAT_RIGHTNext: Using the Abstract API](abstract.md)
diff --git a/docs/func_groups/cycle_indicators.md b/docs/func_groups/cycle_indicators.md
index c1514927a..db5761f26 100644
--- a/docs/func_groups/cycle_indicators.md
+++ b/docs/func_groups/cycle_indicators.md
@@ -2,38 +2,34 @@
 ### HT_DCPERIOD - Hilbert Transform - Dominant Cycle Period
 NOTE: The ``HT_DCPERIOD`` function has an unstable period.  
 ```python
-real = HT_DCPERIOD(close)
+real = HT_DCPERIOD(real)
 ```
 
-Learn more about the Hilbert Transform - Dominant Cycle Period at [tadoc.org](http://www.tadoc.org/indicator/HT_DCPERIOD.htm).  
 ### HT_DCPHASE - Hilbert Transform - Dominant Cycle Phase
 NOTE: The ``HT_DCPHASE`` function has an unstable period.  
 ```python
-real = HT_DCPHASE(close)
+real = HT_DCPHASE(real)
 ```
 
-Learn more about the Hilbert Transform - Dominant Cycle Phase at [tadoc.org](http://www.tadoc.org/indicator/HT_DCPHASE.htm).  
 ### HT_PHASOR - Hilbert Transform - Phasor Components
 NOTE: The ``HT_PHASOR`` function has an unstable period.  
 ```python
-inphase, quadrature = HT_PHASOR(close)
+inphase, quadrature = HT_PHASOR(real)
 ```
 
-Learn more about the Hilbert Transform - Phasor Components at [tadoc.org](http://www.tadoc.org/indicator/HT_PHASOR.htm).  
 ### HT_SINE - Hilbert Transform - SineWave
 NOTE: The ``HT_SINE`` function has an unstable period.  
 ```python
-sine, leadsine = HT_SINE(close)
+sine, leadsine = HT_SINE(real)
 ```
 
-Learn more about the Hilbert Transform - SineWave at [tadoc.org](http://www.tadoc.org/indicator/HT_SINE.htm).  
 ### HT_TRENDMODE - Hilbert Transform - Trend vs Cycle Mode
 NOTE: The ``HT_TRENDMODE`` function has an unstable period.  
 ```python
-integer = HT_TRENDMODE(close)
+integer = HT_TRENDMODE(real)
 ```
 
-Learn more about the Hilbert Transform - Trend vs Cycle Mode at [tadoc.org](http://www.tadoc.org/indicator/HT_TRENDMODE.htm).  
 
-[Documentation Index](../doc_index.html)
-[FLOAT_RIGHTAll Function Groups](../funcs.html)
+[Documentation Index](../doc_index.md)
+
+[FLOAT_RIGHTAll Function Groups](../funcs.md)
diff --git a/docs/func_groups/math_operators.md b/docs/func_groups/math_operators.md
index e27c6004f..7a48fde22 100644
--- a/docs/func_groups/math_operators.md
+++ b/docs/func_groups/math_operators.md
@@ -1,59 +1,60 @@
 # Math Operator Functions
 ### ADD - Vector Arithmetic Add
 ```python
-real = ADD(high, low)
+real = ADD(real0, real1)
 ```
 
 ### DIV - Vector Arithmetic Div
 ```python
-real = DIV(high, low)
+real = DIV(real0, real1)
 ```
 
 ### MAX - Highest value over a specified period
 ```python
-real = MAX(close, timeperiod=30)
+real = MAX(real, timeperiod=30)
 ```
 
 ### MAXINDEX - Index of highest value over a specified period
 ```python
-integer = MAXINDEX(close, timeperiod=30)
+integer = MAXINDEX(real, timeperiod=30)
 ```
 
 ### MIN - Lowest value over a specified period
 ```python
-real = MIN(close, timeperiod=30)
+real = MIN(real, timeperiod=30)
 ```
 
 ### MININDEX - Index of lowest value over a specified period
 ```python
-integer = MININDEX(close, timeperiod=30)
+integer = MININDEX(real, timeperiod=30)
 ```
 
 ### MINMAX - Lowest and highest values over a specified period
 ```python
-min, max = MINMAX(close, timeperiod=30)
+min, max = MINMAX(real, timeperiod=30)
 ```
 
 ### MINMAXINDEX - Indexes of lowest and highest values over a specified period
 ```python
-minidx, maxidx = MINMAXINDEX(close, timeperiod=30)
+minidx, maxidx = MINMAXINDEX(real, timeperiod=30)
 ```
 
 ### MULT - Vector Arithmetic Mult
 ```python
-real = MULT(high, low)
+real = MULT(real0, real1)
 ```
 
-### SUB - Vector Arithmetic Substraction
+### SUB - Vector Arithmetic Subtraction
 ```python
-real = SUB(high, low)
+real = SUB(real0, real1)
 ```
 
 ### SUM - Summation
 ```python
-real = SUM(close, timeperiod=30)
+real = SUM(real, timeperiod=30)
 ```
 
 
-[Documentation Index](../doc_index.html)
-[FLOAT_RIGHTAll Function Groups](../funcs.html)
+[Documentation Index](../doc_index.md)
+
+[FLOAT_RIGHTAll Function Groups](../funcs.md)
diff --git a/docs/func_groups/math_transform.md b/docs/func_groups/math_transform.md
index 769659fc4..749f8d034 100644
--- a/docs/func_groups/math_transform.md
+++ b/docs/func_groups/math_transform.md
@@ -1,79 +1,80 @@
 # Math Transform Functions
 ### ACOS - Vector Trigonometric ACos
 ```python
-real = ACOS(close)
+real = ACOS(real)
 ```
 
 ### ASIN - Vector Trigonometric ASin
 ```python
-real = ASIN(close)
+real = ASIN(real)
 ```
 
 ### ATAN - Vector Trigonometric ATan
 ```python
-real = ATAN(close)
+real = ATAN(real)
 ```
 
 ### CEIL - Vector Ceil
 ```python
-real = CEIL(close)
+real = CEIL(real)
 ```
 
 ### COS - Vector Trigonometric Cos
 ```python
-real = COS(close)
+real = COS(real)
 ```
 
 ### COSH - Vector Trigonometric Cosh
 ```python
-real = COSH(close)
+real = COSH(real)
 ```
 
 ### EXP - Vector Arithmetic Exp
 ```python
-real = EXP(close)
+real = EXP(real)
 ```
 
 ### FLOOR - Vector Floor
 ```python
-real = FLOOR(close)
+real = FLOOR(real)
 ```
 
 ### LN - Vector Log Natural
 ```python
-real = LN(close)
+real = LN(real)
 ```
 
 ### LOG10 - Vector Log10
 ```python
-real = LOG10(close)
+real = LOG10(real)
 ```
 
 ### SIN - Vector Trigonometric Sin
 ```python
-real = SIN(close)
+real = SIN(real)
 ```
 
 ### SINH - Vector Trigonometric Sinh
 ```python
-real = SINH(close)
+real = SINH(real)
 ```
 
 ### SQRT - Vector Square Root
 ```python
-real = SQRT(close)
+real = SQRT(real)
 ```
 
 ### TAN - Vector Trigonometric Tan
 ```python
-real = TAN(close)
+real = TAN(real)
 ```
 
 ### TANH - Vector Trigonometric Tanh
 ```python
-real = TANH(close)
+real = TANH(real)
 ```
 
 
-[Documentation Index](../doc_index.html)
-[FLOAT_RIGHTAll Function Groups](../funcs.html)
+[Documentation Index](../doc_index.md)
+
+[FLOAT_RIGHTAll Function Groups](../funcs.md)
diff --git a/docs/func_groups/momentum_indicators.md b/docs/func_groups/momentum_indicators.md
index 26088294b..c859d89b2 100644
--- a/docs/func_groups/momentum_indicators.md
+++ b/docs/func_groups/momentum_indicators.md
@@ -5,72 +5,68 @@ NOTE: The ``ADX`` function has an unstable period.
 real = ADX(high, low, close, timeperiod=14)
 ```
 
-Learn more about the Average Directional Movement Index at [tadoc.org](http://www.tadoc.org/indicator/ADX.htm).  
 ### ADXR - Average Directional Movement Index Rating
 NOTE: The ``ADXR`` function has an unstable period.  
 ```python
 real = ADXR(high, low, close, timeperiod=14)
 ```
 
-Learn more about the Average Directional Movement Index Rating at [tadoc.org](http://www.tadoc.org/indicator/ADXR.htm).  
 ### APO - Absolute Price Oscillator
 ```python
-real = APO(close, fastperiod=12, slowperiod=26, matype=0)
+real = APO(real, fastperiod=12, slowperiod=26, matype=0)
 ```
 
-Learn more about the Absolute Price Oscillator at [tadoc.org](http://www.tadoc.org/indicator/APO.htm).  
 ### AROON - Aroon
 ```python
 aroondown, aroonup = AROON(high, low, timeperiod=14)
 ```
 
-Learn more about the Aroon at [tadoc.org](http://www.tadoc.org/indicator/AROON.htm).  
 ### AROONOSC - Aroon Oscillator
 ```python
 real = AROONOSC(high, low, timeperiod=14)
 ```
 
-Learn more about the Aroon Oscillator at [tadoc.org](http://www.tadoc.org/indicator/AROONOSC.htm).  
 ### BOP - Balance Of Power
 ```python
 real = BOP(open, high, low, close)
 ```
 
-Learn more about the Balance Of Power at [tadoc.org](http://www.tadoc.org/indicator/BOP.htm).  
 ### CCI - Commodity Channel Index
 ```python
 real = CCI(high, low, close, timeperiod=14)
 ```
 
-Learn more about the Commodity Channel Index at [tadoc.org](http://www.tadoc.org/indicator/CCI.htm).  
 ### CMO - Chande Momentum Oscillator
 NOTE: The ``CMO`` function has an unstable period.  
 ```python
-real = CMO(close, timeperiod=14)
+real = CMO(real, timeperiod=14)
 ```
 
-Learn more about the Chande Momentum Oscillator at [tadoc.org](http://www.tadoc.org/indicator/CMO.htm).  
 ### DX - Directional Movement Index
 NOTE: The ``DX`` function has an unstable period.  
 ```python
 real = DX(high, low, close, timeperiod=14)
 ```
 
-Learn more about the Directional Movement Index at [tadoc.org](http://www.tadoc.org/indicator/DX.htm).  
+### IMI - Intraday Momentum Index
+NOTE: The ``IMI`` function has an unstable period.
+```python
+real = IMI(open, close, timeperiod=14)
+```
+
 ### MACD - Moving Average Convergence/Divergence
 ```python
-macd, macdsignal, macdhist = MACD(close, fastperiod=12, slowperiod=26, signalperiod=9)
+macd, macdsignal, macdhist = MACD(real, fastperiod=12, slowperiod=26, signalperiod=9)
 ```
 
-Learn more about the Moving Average Convergence/Divergence at [tadoc.org](http://www.tadoc.org/indicator/MACD.htm).  
 ### MACDEXT - MACD with controllable MA type
 ```python
-macd, macdsignal, macdhist = MACDEXT(close, fastperiod=12, fastmatype=0, slowperiod=26, slowmatype=0, signalperiod=9, signalmatype=0)
+macd, macdsignal, macdhist = MACDEXT(real, fastperiod=12, fastmatype=0, slowperiod=26, slowmatype=0, signalperiod=9, signalmatype=0)
 ```
 
 ### MACDFIX - Moving Average Convergence/Divergence Fix 12/26
 ```python
-macd, macdsignal, macdhist = MACDFIX(close, signalperiod=9)
+macd, macdsignal, macdhist = MACDFIX(real, signalperiod=9)
 ```
 
 ### MFI - Money Flow Index
@@ -79,115 +75,98 @@ NOTE: The ``MFI`` function has an unstable period.
 real = MFI(high, low, close, volume, timeperiod=14)
 ```
 
-Learn more about the Money Flow Index at [tadoc.org](http://www.tadoc.org/indicator/MFI.htm).  
 ### MINUS_DI - Minus Directional Indicator
 NOTE: The ``MINUS_DI`` function has an unstable period.  
 ```python
 real = MINUS_DI(high, low, close, timeperiod=14)
 ```
 
-Learn more about the Minus Directional Indicator at [tadoc.org](http://www.tadoc.org/indicator/MINUS_DI.htm).  
 ### MINUS_DM - Minus Directional Movement
 NOTE: The ``MINUS_DM`` function has an unstable period.  
 ```python
 real = MINUS_DM(high, low, timeperiod=14)
 ```
 
-Learn more about the Minus Directional Movement at [tadoc.org](http://www.tadoc.org/indicator/MINUS_DM.htm).  
 ### MOM - Momentum
 ```python
-real = MOM(close, timeperiod=10)
+real = MOM(real, timeperiod=10)
 ```
 
-Learn more about the Momentum at [tadoc.org](http://www.tadoc.org/indicator/MOM.htm).  
 ### PLUS_DI - Plus Directional Indicator
 NOTE: The ``PLUS_DI`` function has an unstable period.  
 ```python
 real = PLUS_DI(high, low, close, timeperiod=14)
 ```
 
-Learn more about the Plus Directional Indicator at [tadoc.org](http://www.tadoc.org/indicator/PLUS_DI.htm).  
 ### PLUS_DM - Plus Directional Movement
 NOTE: The ``PLUS_DM`` function has an unstable period.  
 ```python
 real = PLUS_DM(high, low, timeperiod=14)
 ```
 
-Learn more about the Plus Directional Movement at [tadoc.org](http://www.tadoc.org/indicator/PLUS_DM.htm).  
 ### PPO - Percentage Price Oscillator
 ```python
-real = PPO(close, fastperiod=12, slowperiod=26, matype=0)
+real = PPO(real, fastperiod=12, slowperiod=26, matype=0)
 ```
 
-Learn more about the Percentage Price Oscillator at [tadoc.org](http://www.tadoc.org/indicator/PPO.htm).  
 ### ROC - Rate of change : ((price/prevPrice)-1)*100
 ```python
-real = ROC(close, timeperiod=10)
+real = ROC(real, timeperiod=10)
 ```
 
-Learn more about the Rate of change : ((price/prevPrice)-1)*100 at [tadoc.org](http://www.tadoc.org/indicator/ROC.htm).  
 ### ROCP - Rate of change Percentage: (price-prevPrice)/prevPrice
 ```python
-real = ROCP(close, timeperiod=10)
+real = ROCP(real, timeperiod=10)
 ```
 
-Learn more about the Rate of change Percentage: (price-prevPrice)/prevPrice at [tadoc.org](http://www.tadoc.org/indicator/ROCP.htm).  
 ### ROCR - Rate of change ratio: (price/prevPrice)
 ```python
-real = ROCR(close, timeperiod=10)
+real = ROCR(real, timeperiod=10)
 ```
 
-Learn more about the Rate of change ratio: (price/prevPrice) at [tadoc.org](http://www.tadoc.org/indicator/ROCR.htm).  
 ### ROCR100 - Rate of change ratio 100 scale: (price/prevPrice)*100
 ```python
-real = ROCR100(close, timeperiod=10)
+real = ROCR100(real, timeperiod=10)
 ```
 
-Learn more about the Rate of change ratio 100 scale: (price/prevPrice)*100 at [tadoc.org](http://www.tadoc.org/indicator/ROCR100.htm).  
 ### RSI - Relative Strength Index
 NOTE: The ``RSI`` function has an unstable period.  
 ```python
-real = RSI(close, timeperiod=14)
+real = RSI(real, timeperiod=14)
 ```
 
-Learn more about the Relative Strength Index at [tadoc.org](http://www.tadoc.org/indicator/RSI.htm).  
 ### STOCH - Stochastic
 ```python
 slowk, slowd = STOCH(high, low, close, fastk_period=5, slowk_period=3, slowk_matype=0, slowd_period=3, slowd_matype=0)
 ```
 
-Learn more about the Stochastic at [tadoc.org](http://www.tadoc.org/indicator/STOCH.htm).  
 ### STOCHF - Stochastic Fast
 ```python
 fastk, fastd = STOCHF(high, low, close, fastk_period=5, fastd_period=3, fastd_matype=0)
 ```
 
-Learn more about the Stochastic Fast at [tadoc.org](http://www.tadoc.org/indicator/STOCHF.htm).  
 ### STOCHRSI - Stochastic Relative Strength Index
 NOTE: The ``STOCHRSI`` function has an unstable period.  
 ```python
-fastk, fastd = STOCHRSI(close, timeperiod=14, fastk_period=5, fastd_period=3, fastd_matype=0)
+fastk, fastd = STOCHRSI(real, timeperiod=14, fastk_period=5, fastd_period=3, fastd_matype=0)
 ```
 
-Learn more about the Stochastic Relative Strength Index at [tadoc.org](http://www.tadoc.org/indicator/STOCHRSI.htm).  
 ### TRIX - 1-day Rate-Of-Change (ROC) of a Triple Smooth EMA
 ```python
-real = TRIX(close, timeperiod=30)
+real = TRIX(real, timeperiod=30)
 ```
 
-Learn more about the 1-day Rate-Of-Change (ROC) of a Triple Smooth EMA at [tadoc.org](http://www.tadoc.org/indicator/TRIX.htm).  
 ### ULTOSC - Ultimate Oscillator
 ```python
 real = ULTOSC(high, low, close, timeperiod1=7, timeperiod2=14, timeperiod3=28)
 ```
 
-Learn more about the Ultimate Oscillator at [tadoc.org](http://www.tadoc.org/indicator/ULTOSC.htm).  
 ### WILLR - Williams' %R
 ```python
 real = WILLR(high, low, close, timeperiod=14)
 ```
 
-Learn more about the Williams' %R at [tadoc.org](http://www.tadoc.org/indicator/WILLR.htm).  
 
-[Documentation Index](../doc_index.html)
-[FLOAT_RIGHTAll Function Groups](../funcs.html)
+[Documentation Index](../doc_index.md)
+
+[FLOAT_RIGHTAll Function Groups](../funcs.md)
diff --git a/docs/func_groups/overlap_studies.md b/docs/func_groups/overlap_studies.md
index 2add5f1a7..8c6305223 100644
--- a/docs/func_groups/overlap_studies.md
+++ b/docs/func_groups/overlap_studies.md
@@ -1,72 +1,68 @@
 # Overlap Studies Functions
+### ACCBANDS - Acceleration Bands
+```python
+upperband, middleband, lowerband = ACCBANDS(high, low, close, timeperiod=20)
+```
+
 ### BBANDS - Bollinger Bands
 ```python
-upperband, middleband, lowerband = BBANDS(close, timeperiod=5, nbdevup=2, nbdevdn=2, matype=0)
+upperband, middleband, lowerband = BBANDS(real, timeperiod=5, nbdevup=2, nbdevdn=2, matype=0)
 ```
 
-Learn more about the Bollinger Bands at [tadoc.org](http://www.tadoc.org/indicator/BBANDS.htm).  
 ### DEMA - Double Exponential Moving Average
 ```python
-real = DEMA(close, timeperiod=30)
+real = DEMA(real, timeperiod=30)
 ```
 
-Learn more about the Double Exponential Moving Average at [tadoc.org](http://www.tadoc.org/indicator/DEMA.htm).  
 ### EMA - Exponential Moving Average
 NOTE: The ``EMA`` function has an unstable period.  
 ```python
-real = EMA(close, timeperiod=30)
+real = EMA(real, timeperiod=30)
 ```
 
-Learn more about the Exponential Moving Average at [tadoc.org](http://www.tadoc.org/indicator/EMA.htm).  
 ### HT_TRENDLINE - Hilbert Transform - Instantaneous Trendline
 NOTE: The ``HT_TRENDLINE`` function has an unstable period.  
 ```python
-real = HT_TRENDLINE(close)
+real = HT_TRENDLINE(real)
 ```
 
-Learn more about the Hilbert Transform - Instantaneous Trendline at [tadoc.org](http://www.tadoc.org/indicator/HT_TRENDLINE.htm).  
 ### KAMA - Kaufman Adaptive Moving Average
 NOTE: The ``KAMA`` function has an unstable period.  
 ```python
-real = KAMA(close, timeperiod=30)
+real = KAMA(real, timeperiod=30)
 ```
 
-Learn more about the Kaufman Adaptive Moving Average at [tadoc.org](http://www.tadoc.org/indicator/KAMA.htm).  
 ### MA - Moving average
 ```python
-real = MA(close, timeperiod=30, matype=0)
+real = MA(real, timeperiod=30, matype=0)
 ```
 
 ### MAMA - MESA Adaptive Moving Average
 NOTE: The ``MAMA`` function has an unstable period.  
 ```python
-mama, fama = MAMA(close, fastlimit=0, slowlimit=0)
+mama, fama = MAMA(real, fastlimit=0, slowlimit=0)
 ```
 
-Learn more about the MESA Adaptive Moving Average at [tadoc.org](http://www.tadoc.org/indicator/MAMA.htm).  
 ### MAVP - Moving average with variable period
 ```python
-real = MAVP(close, periods, minperiod=2, maxperiod=30, matype=0)
+real = MAVP(real, periods, minperiod=2, maxperiod=30, matype=0)
 ```
 
 ### MIDPOINT - MidPoint over period
 ```python
-real = MIDPOINT(close, timeperiod=14)
+real = MIDPOINT(real, timeperiod=14)
 ```
 
-Learn more about the MidPoint over period at [tadoc.org](http://www.tadoc.org/indicator/MIDPOINT.htm).  
 ### MIDPRICE - Midpoint Price over period
 ```python
 real = MIDPRICE(high, low, timeperiod=14)
 ```
 
-Learn more about the Midpoint Price over period at [tadoc.org](http://www.tadoc.org/indicator/MIDPRICE.htm).  
 ### SAR - Parabolic SAR
 ```python
 real = SAR(high, low, acceleration=0, maximum=0)
 ```
 
-Learn more about the Parabolic SAR at [tadoc.org](http://www.tadoc.org/indicator/SAR.htm).  
 ### SAREXT - Parabolic SAR - Extended
 ```python
 real = SAREXT(high, low, startvalue=0, offsetonreverse=0, accelerationinitlong=0, accelerationlong=0, accelerationmaxlong=0, accelerationinitshort=0, accelerationshort=0, accelerationmaxshort=0)
@@ -74,35 +70,30 @@ real = SAREXT(high, low, startvalue=0, offsetonreverse=0, accelerationinitlong=0
 
 ### SMA - Simple Moving Average
 ```python
-real = SMA(close, timeperiod=30)
+real = SMA(real, timeperiod=30)
 ```
 
-Learn more about the Simple Moving Average at [tadoc.org](http://www.tadoc.org/indicator/SMA.htm).  
 ### T3 - Triple Exponential Moving Average (T3)
 NOTE: The ``T3`` function has an unstable period.  
 ```python
-real = T3(close, timeperiod=5, vfactor=0)
+real = T3(real, timeperiod=5, vfactor=0)
 ```
 
-Learn more about the Triple Exponential Moving Average (T3) at [tadoc.org](http://www.tadoc.org/indicator/T3.htm).  
 ### TEMA - Triple Exponential Moving Average
 ```python
-real = TEMA(close, timeperiod=30)
+real = TEMA(real, timeperiod=30)
 ```
 
-Learn more about the Triple Exponential Moving Average at [tadoc.org](http://www.tadoc.org/indicator/TEMA.htm).  
 ### TRIMA - Triangular Moving Average
 ```python
-real = TRIMA(close, timeperiod=30)
+real = TRIMA(real, timeperiod=30)
 ```
 
-Learn more about the Triangular Moving Average at [tadoc.org](http://www.tadoc.org/indicator/TRIMA.htm).  
 ### WMA - Weighted Moving Average
 ```python
-real = WMA(close, timeperiod=30)
+real = WMA(real, timeperiod=30)
 ```
 
-Learn more about the Weighted Moving Average at [tadoc.org](http://www.tadoc.org/indicator/WMA.htm).  
+[Documentation Index](../doc_index.md)
 
-[Documentation Index](../doc_index.html)
-[FLOAT_RIGHTAll Function Groups](../funcs.html)
+[FLOAT_RIGHTAll Function Groups](../funcs.md)
diff --git a/docs/func_groups/pattern_recognition.md b/docs/func_groups/pattern_recognition.md
index d5c8b9046..39a3efa9d 100644
--- a/docs/func_groups/pattern_recognition.md
+++ b/docs/func_groups/pattern_recognition.md
@@ -305,5 +305,6 @@ integer = CDLXSIDEGAP3METHODS(open, high, low, close)
 ```
 
 
-[Documentation Index](../doc_index.html)
-[FLOAT_RIGHTAll Function Groups](../funcs.html)
+[Documentation Index](../doc_index.md)
+
+[FLOAT_RIGHTAll Function Groups](../funcs.md)
\ No newline at end of file
diff --git a/docs/func_groups/price_transform.md b/docs/func_groups/price_transform.md
index 5ec35c54e..3bf5e132e 100644
--- a/docs/func_groups/price_transform.md
+++ b/docs/func_groups/price_transform.md
@@ -1,28 +1,29 @@
 # Price Transform Functions
+### AVGDEV - Average Deviation
+```python
+real = AVGDEV(real, timeperiod=14)
+```
+
 ### AVGPRICE - Average Price
 ```python
 real = AVGPRICE(open, high, low, close)
 ```
 
-Learn more about the Average Price at [tadoc.org](http://www.tadoc.org/indicator/AVGPRICE.htm).  
 ### MEDPRICE - Median Price
 ```python
 real = MEDPRICE(high, low)
 ```
 
-Learn more about the Median Price at [tadoc.org](http://www.tadoc.org/indicator/MEDPRICE.htm).  
 ### TYPPRICE - Typical Price
 ```python
 real = TYPPRICE(high, low, close)
 ```
 
-Learn more about the Typical Price at [tadoc.org](http://www.tadoc.org/indicator/TYPPRICE.htm).  
 ### WCLPRICE - Weighted Close Price
 ```python
 real = WCLPRICE(high, low, close)
 ```
 
-Learn more about the Weighted Close Price at [tadoc.org](http://www.tadoc.org/indicator/WCLPRICE.htm).  
 
-[Documentation Index](../doc_index.html)
-[FLOAT_RIGHTAll Function Groups](../funcs.html)
+[Documentation Index](../doc_index.md)
+[FLOAT_RIGHTAll Function Groups](../funcs.md)
diff --git a/docs/func_groups/statistic_functions.md b/docs/func_groups/statistic_functions.md
index 5f1663939..db629952c 100644
--- a/docs/func_groups/statistic_functions.md
+++ b/docs/func_groups/statistic_functions.md
@@ -1,58 +1,50 @@
 # Statistic Functions
 ### BETA - Beta
 ```python
-real = BETA(high, low, timeperiod=5)
+real = BETA(real0, real1, timeperiod=5)
 ```
 
-Learn more about the Beta at [tadoc.org](http://www.tadoc.org/indicator/BETA.htm).  
 ### CORREL - Pearson's Correlation Coefficient (r)
 ```python
-real = CORREL(high, low, timeperiod=30)
+real = CORREL(real0, real1, timeperiod=30)
 ```
 
-Learn more about the Pearson's Correlation Coefficient (r) at [tadoc.org](http://www.tadoc.org/indicator/CORREL.htm).  
 ### LINEARREG - Linear Regression
 ```python
-real = LINEARREG(close, timeperiod=14)
+real = LINEARREG(real, timeperiod=14)
 ```
 
-Learn more about the Linear Regression at [tadoc.org](http://www.tadoc.org/indicator/LINEARREG.htm).  
 ### LINEARREG_ANGLE - Linear Regression Angle
 ```python
-real = LINEARREG_ANGLE(close, timeperiod=14)
+real = LINEARREG_ANGLE(real, timeperiod=14)
 ```
 
-Learn more about the Linear Regression Angle at [tadoc.org](http://www.tadoc.org/indicator/LINEARREG_ANGLE.htm).  
 ### LINEARREG_INTERCEPT - Linear Regression Intercept
 ```python
-real = LINEARREG_INTERCEPT(close, timeperiod=14)
+real = LINEARREG_INTERCEPT(real, timeperiod=14)
 ```
 
-Learn more about the Linear Regression Intercept at [tadoc.org](http://www.tadoc.org/indicator/LINEARREG_INTERCEPT.htm).  
 ### LINEARREG_SLOPE - Linear Regression Slope
 ```python
-real = LINEARREG_SLOPE(close, timeperiod=14)
+real = LINEARREG_SLOPE(real, timeperiod=14)
 ```
 
-Learn more about the Linear Regression Slope at [tadoc.org](http://www.tadoc.org/indicator/LINEARREG_SLOPE.htm).  
 ### STDDEV - Standard Deviation
 ```python
-real = STDDEV(close, timeperiod=5, nbdev=1)
+real = STDDEV(real, timeperiod=5, nbdev=1)
 ```
 
-Learn more about the Standard Deviation at [tadoc.org](http://www.tadoc.org/indicator/STDDEV.htm).  
 ### TSF - Time Series Forecast
 ```python
-real = TSF(close, timeperiod=14)
+real = TSF(real, timeperiod=14)
 ```
 
-Learn more about the Time Series Forecast at [tadoc.org](http://www.tadoc.org/indicator/TSF.htm).  
 ### VAR - Variance
 ```python
-real = VAR(close, timeperiod=5, nbdev=1)
+real = VAR(real, timeperiod=5, nbdev=1)
 ```
 
-Learn more about the Variance at [tadoc.org](http://www.tadoc.org/indicator/VAR.htm).  
 
-[Documentation Index](../doc_index.html)
-[FLOAT_RIGHTAll Function Groups](../funcs.html)
+[Documentation Index](../doc_index.md)
+
+[FLOAT_RIGHTAll Function Groups](../funcs.md)
diff --git a/docs/func_groups/volatility_indicators.md b/docs/func_groups/volatility_indicators.md
index 3f906e97b..d14337b33 100644
--- a/docs/func_groups/volatility_indicators.md
+++ b/docs/func_groups/volatility_indicators.md
@@ -5,20 +5,18 @@ NOTE: The ``ATR`` function has an unstable period.
 real = ATR(high, low, close, timeperiod=14)
 ```
 
-Learn more about the Average True Range at [tadoc.org](http://www.tadoc.org/indicator/ATR.htm).  
 ### NATR - Normalized Average True Range
 NOTE: The ``NATR`` function has an unstable period.  
 ```python
 real = NATR(high, low, close, timeperiod=14)
 ```
 
-Learn more about the Normalized Average True Range at [tadoc.org](http://www.tadoc.org/indicator/NATR.htm).  
 ### TRANGE - True Range
 ```python
 real = TRANGE(high, low, close)
 ```
 
-Learn more about the True Range at [tadoc.org](http://www.tadoc.org/indicator/TRANGE.htm).  
 
-[Documentation Index](../doc_index.html)
-[FLOAT_RIGHTAll Function Groups](../funcs.html)
+[Documentation Index](../doc_index.md)
+
+[FLOAT_RIGHTAll Function Groups](../funcs.md)
\ No newline at end of file
diff --git a/docs/func_groups/volume_indicators.md b/docs/func_groups/volume_indicators.md
index 27da84a93..c64fc29c3 100644
--- a/docs/func_groups/volume_indicators.md
+++ b/docs/func_groups/volume_indicators.md
@@ -4,19 +4,17 @@
 real = AD(high, low, close, volume)
 ```
 
-Learn more about the Chaikin A/D Line at [tadoc.org](http://www.tadoc.org/indicator/AD.htm).  
 ### ADOSC - Chaikin A/D Oscillator
 ```python
 real = ADOSC(high, low, close, volume, fastperiod=3, slowperiod=10)
 ```
 
-Learn more about the Chaikin A/D Oscillator at [tadoc.org](http://www.tadoc.org/indicator/ADOSC.htm).  
 ### OBV - On Balance Volume
 ```python
 real = OBV(close, volume)
 ```
 
-Learn more about the On Balance Volume at [tadoc.org](http://www.tadoc.org/indicator/OBV.htm).  
 
-[Documentation Index](../doc_index.html)
-[FLOAT_RIGHTAll Function Groups](../funcs.html)
+[Documentation Index](../doc_index.md)
+
+[FLOAT_RIGHTAll Function Groups](../funcs.md)
\ No newline at end of file
diff --git a/docs/funcs.md b/docs/funcs.md
index 897d231be..14ab13776 100644
--- a/docs/funcs.md
+++ b/docs/funcs.md
@@ -1,17 +1,17 @@
 # All Supported Indicators and Functions
 
-* [Overlap Studies](func_groups/overlap_studies.html)
-* [Momentum Indicators](func_groups/momentum_indicators.html)
-* [Volume Indicators](func_groups/volume_indicators.html)
-* [Volatility Indicators](func_groups/volatility_indicators.html)
-* [Price Transform](func_groups/price_transform.html)
-* [Cycle Indicators](func_groups/cycle_indicators.html)
-* [Pattern Recognition](func_groups/pattern_recognition.html)
-* [Statistic Functions](func_groups/statistic_functions.html)
-* [Math Transform](func_groups/math_transform.html)
-* [Math Operators](func_groups/math_operators.html)
+* [Overlap Studies](func_groups/overlap_studies.md)
+* [Momentum Indicators](func_groups/momentum_indicators.md)
+* [Volume Indicators](func_groups/volume_indicators.md)
+* [Volatility Indicators](func_groups/volatility_indicators.md)
+* [Price Transform](func_groups/price_transform.md)
+* [Cycle Indicators](func_groups/cycle_indicators.md)
+* [Pattern Recognition](func_groups/pattern_recognition.md)
+* [Statistic Functions](func_groups/statistic_functions.md)
+* [Math Transform](func_groups/math_transform.md)
+* [Math Operators](func_groups/math_operators.md)
 
-#### [Overlap Studies](func_groups/overlap_studies.html)
+#### [Overlap Studies](func_groups/overlap_studies.md)
 
 ```
 BBANDS               Bollinger Bands
@@ -33,7 +33,7 @@ TRIMA                Triangular Moving Average
 WMA                  Weighted Moving Average
 ```
 
-#### [Momentum Indicators](func_groups/momentum_indicators.html)
+#### [Momentum Indicators](func_groups/momentum_indicators.md)
 
 ```
 ADX                  Average Directional Movement Index
@@ -68,7 +68,7 @@ ULTOSC               Ultimate Oscillator
 WILLR                Williams' %R
 ```
 
-#### [Volume Indicators](func_groups/volume_indicators.html)
+#### [Volume Indicators](func_groups/volume_indicators.md)
 
 ```
 AD                   Chaikin A/D Line
@@ -76,7 +76,7 @@ ADOSC                Chaikin A/D Oscillator
 OBV                  On Balance Volume
 ```
 
-#### [Cycle Indicators](func_groups/cycle_indicators.html)
+#### [Cycle Indicators](func_groups/cycle_indicators.md)
 
 ```
 HT_DCPERIOD          Hilbert Transform - Dominant Cycle Period
@@ -86,7 +86,7 @@ HT_SINE              Hilbert Transform - SineWave
 HT_TRENDMODE         Hilbert Transform - Trend vs Cycle Mode
 ```
 
-#### [Price Transform](func_groups/price_transform.html)
+#### [Price Transform](func_groups/price_transform.md)
 
 ```
 AVGPRICE             Average Price
@@ -95,7 +95,7 @@ TYPPRICE             Typical Price
 WCLPRICE             Weighted Close Price
 ```
 
-#### [Volatility Indicators](func_groups/volatility_indicators.html)
+#### [Volatility Indicators](func_groups/volatility_indicators.md)
 
 ```
 ATR                  Average True Range
@@ -103,7 +103,7 @@ NATR                 Normalized Average True Range
 TRANGE               True Range
 ```
 
-#### [Pattern Recognition](func_groups/pattern_recognition.html)
+#### [Pattern Recognition](func_groups/pattern_recognition.md)
 
 ```
 CDL2CROWS            Two Crows
@@ -169,7 +169,7 @@ CDLUPSIDEGAP2CROWS   Upside Gap Two Crows
 CDLXSIDEGAP3METHODS  Upside/Downside Gap Three Methods
 ```
 
-#### [Statistic Functions](func_groups/statistic_functions.html)
+#### [Statistic Functions](func_groups/statistic_functions.md)
 
 ```
 BETA                 Beta
@@ -183,7 +183,7 @@ TSF                  Time Series Forecast
 VAR                  Variance
 ```
 
-#### [Math Transform](func_groups/math_transform.html)
+#### [Math Transform](func_groups/math_transform.md)
 
 ```
 ACOS                 Vector Trigonometric ACos
@@ -203,7 +203,7 @@ TAN                  Vector Trigonometric Tan
 TANH                 Vector Trigonometric Tanh
 ```
 
-#### [Math Operators](func_groups/math_operators.html)
+#### [Math Operators](func_groups/math_operators.md)
 
 ```
 ADD                  Vector Arithmetic Add
@@ -215,8 +215,8 @@ MININDEX             Index of lowest value over a specified period
 MINMAX               Lowest and highest values over a specified period
 MINMAXINDEX          Indexes of lowest and highest values over a specified period
 MULT                 Vector Arithmetic Mult
-SUB                  Vector Arithmetic Substraction
+SUB                  Vector Arithmetic Subtraction
 SUM                  Summation
 ```
 
-[Documentation Index](doc_index.html)
+[Documentation Index](doc_index.md)
diff --git a/docs/generate_html_pages.py b/docs/generate_html_pages.py
index 53915ade5..fe8633353 100644
--- a/docs/generate_html_pages.py
+++ b/docs/generate_html_pages.py
@@ -13,13 +13,12 @@
 # default, lovelace and xcode are "normal" styles
 """
 
-from __future__ import print_function
-
 import os
 import sys
 import talib
 
 import mistune
+
 from pygments import highlight
 from pygments.lexers import get_lexer_by_name
 from pygments.formatters.html import HtmlFormatter
@@ -41,7 +40,7 @@
   <head>
     <meta charset='utf-8' />
     <meta http-equiv="X-UA-Compatible" content="chrome=1" />
-    <meta name="description" content="TA-Lib : Python wrapper for TA-Lib (http://ta-lib.org/)." />
+    <meta name="description" content="TA-Lib : Python wrapper for TA-Lib (https://ta-lib.org/)." />
     <link rel="stylesheet" type="text/css" media="screen" href="http://github.com/stylesheets/stylesheet.css">
     <title>TA-Lib</title>
   </head>
@@ -49,7 +48,7 @@
   <body>
     <div id="header_wrap" class="outer">
         <header class="inner">
-            <a id="forkme_banner" href="https://github.com/mrjbq7/ta-lib">View on GitHub</a>
+            <a id="forkme_banner" href="https://github.com/ta-lib/ta-lib-python">View on GitHub</a>
             <div class="clearfix">
                 <ul id="menu" class="drop">
                     <li><a href="http://github.com/index.html">Home</a></li>
@@ -57,11 +56,11 @@
                 </ul>
             </div>
             <br>
-            <h1 id="project_title"><a href="http://mrjbq7.github.io/ta-lib/">TA-Lib</a></h1>
-            <h2 id="project_tagline">Python wrapper for TA-Lib (http://ta-lib.org/).</h2>
+            <h1 id="project_title"><a href="https://ta-lib.github.io/ta-lib-python/">TA-Lib</a></h1>
+            <h2 id="project_tagline">Python wrapper for TA-Lib (https://ta-lib.org/).</h2>
             <section id="downloads">
-                <a class="zip_download_link" href="https://github.com/mrjbq7/ta-lib/zipball/master">Download this project as a .zip file</a>
-                <a class="tar_download_link" href="https://github.com/mrjbq7/ta-lib/tarball/master">Download this project as a tar.gz file</a>
+                <a class="zip_download_link" href="https://github.com/ta-lib/ta-lib-python/zipball/master">Download this project as a .zip file</a>
+                <a class="tar_download_link" href="https://github.com/ta-lib/ta-lib-python/tarball/master">Download this project as a tar.gz file</a>
             </section>
         </header>
     </div>
@@ -79,9 +78,9 @@
     <div id="footer_wrap" class="outer">
       <footer class="inner">
         <p class="copyright">TA-Lib written by <a href="https://github.com/mrjbq7">mrjbq7</a>
-        and <a href="https://github.com/mrjbq7/ta-lib/network/members">contributors</a></p>
+        and <a href="https://github.com/ta-lib/ta-lib-python/network/members">contributors</a></p>
         
-        <p>Published with <a href="http://pages.github.com/">GitHub Pages</a></p>
+        <p>Published with <a href="https://pages.github.com/">GitHub Pages</a></p>
       </footer>
     </div>
 
@@ -96,24 +95,21 @@ def slugify(string):
 
 def get_doc_links():
     """Returns a dictionary of function names -> upstream documentation link"""
-    tadoc_homepage = 'http://www.tadoc.org/'
+    tadoc_homepage = 'https://www.tadoc.org/'
     html_file_path = os.path.join(INPUT_DIR, '.tadoc.org.html')
     if os.path.exists(html_file_path):
         with open(html_file_path, 'r') as f:
             html = f.read()
     else:
-        if sys.version_info < (2, 8):
-            from urllib2 import urlopen
-        else:
-            from urllib.request import urlopen
+        from urllib.request import urlopen
 
         html = urlopen(tadoc_homepage).read()
-        with open(html_file_path, 'w') as f:
+        with open(html_file_path, 'wb') as f:
             f.write(html)
 
     # find every link that's for an indicator and convert to absolute urls
     soup = BeautifulSoup(html, 'html.parser')
-    links = [a for a in soup.findAll('a') if 'indicator' in a['href']]
+    links = [a for a in soup.find_all('a') if 'indicator' in a['href']]
     ret = {}
     for a in links:
         url = ''.join([tadoc_homepage, a['href']])
@@ -187,8 +183,8 @@ def unpluralize(noun):
                 group_docs.append('Learn more about the %s at [tadoc.org](%s).  ' % (
                     f.info['display_name'], doc_links[func]))
 
-        group_docs.append('\n[Documentation Index](../doc_index.html)')
-        group_docs.append('[FLOAT_RIGHTAll Function Groups](../funcs.html)')
+        group_docs.append('\n[Documentation Index](../doc_index.md)')
+        group_docs.append('[FLOAT_RIGHTAll Function Groups](../funcs.md)')
 
         ret[slugify(group)] = '\n'.join(group_docs) + '\n'
     return ret
@@ -211,11 +207,11 @@ def get_markdown_file_paths():
 
 def _get_markdown_renderer():
     """Returns a function to convert a Markdown string into pygments-highlighted HTML"""
-    class PygmentsHighlighter(mistune.Renderer):
-        def block_code(self, code, lang=None):
-            if not lang:
+    class PygmentsHighlighter(mistune.HTMLRenderer):
+        def block_code(self, code, info=None):
+            if not info:
                 return '\n<pre><code>%s</code></pre>\n' % mistune.escape(code)
-            lexer = get_lexer_by_name(lang, stripall=True)
+            lexer = get_lexer_by_name(info, stripall=True)
             formatter = HtmlFormatter(classprefix='highlight ')
             return highlight(code, lexer, formatter)
     return mistune.Markdown(renderer=PygmentsHighlighter())
@@ -227,6 +223,7 @@ def run_convert_to_html(output_dir):
     for md_file_path in get_markdown_file_paths():
         with open(md_file_path, 'r') as f:
             html = markdown_to_html(f.read())
+            html = html.replace('.md">', '.html">')
 
         head = HEADER
         if 'func_groups' in md_file_path:
diff --git a/docs/index.md b/docs/index.md
index e0ed41ad8..efe01ac12 100644
--- a/docs/index.md
+++ b/docs/index.md
@@ -1,6 +1,6 @@
 # About
 
-This is a Python wrapper for [TA-LIB](http://ta-lib.org) based on Cython
+This is a Python wrapper for [TA-LIB](https://ta-lib.org) based on Cython
 instead of SWIG. From the homepage:
 
 > TA-Lib is widely used by trading software developers requiring to perform
@@ -11,12 +11,12 @@ instead of SWIG. From the homepage:
 > * Candlestick pattern recognition
 > * Open-source API for C/C++, Java, Perl, Python and 100% Managed .NET
 
-The original Python bindings use [SWIG](http://swig.org) which unfortunately
+The original Python bindings use [SWIG](https://swig.org) which unfortunately
 are difficult to install and aren't as efficient as they could be. Therefore
 this project uses Cython and Numpy to efficiently and cleanly bind to TA-Lib
 -- producing results 2-4 times faster than the SWIG interface.
 
-#### [Install TA-Lib](install.html) or [Read the Docs](doc_index.html)
+#### [Install TA-Lib](install.md) or [Read the Docs](doc_index.md)
 
 ## Examples
 
@@ -94,7 +94,7 @@ slowk, slowd = STOCH(input_arrays, 5, 3, 0, 3, 0) # uses high, low, close by def
 slowk, slowd = STOCH(input_arrays, 5, 3, 0, 3, 0, prices=['high', 'low', 'open'])
 ```
 
-Learn about more advanced usage of TA-Lib [here](abstract.html).
+Learn about more advanced usage of TA-Lib [here](abstract.md).
 
 ## Supported Indicators
 
@@ -111,18 +111,18 @@ print talib.get_function_groups()
 
 ### Function Groups
 
-* [Overlap Studies](func_groups/overlap_studies.html)
-* [Momentum Indicators](func_groups/momentum_indicators.html)
-* [Volume Indicators](func_groups/volume_indicators.html)
-* [Volatility Indicators](func_groups/volatility_indicators.html)
-* [Price Transform](func_groups/price_transform.html)
-* [Cycle Indicators](func_groups/cycle_indicators.html)
-* [Pattern Recognition](func_groups/pattern_recognition.html)
-* [Statistic Functions](func_groups/statistic_functions.html)
-* [Math Transform](func_groups/math_transform.html)
-* [Math Operators](func_groups/math_operators.html)
+* [Overlap Studies](func_groups/overlap_studies.md)
+* [Momentum Indicators](func_groups/momentum_indicators.md)
+* [Volume Indicators](func_groups/volume_indicators.md)
+* [Volatility Indicators](func_groups/volatility_indicators.md)
+* [Price Transform](func_groups/price_transform.md)
+* [Cycle Indicators](func_groups/cycle_indicators.md)
+* [Pattern Recognition](func_groups/pattern_recognition.md)
+* [Statistic Functions](func_groups/statistic_functions.md)
+* [Math Transform](func_groups/math_transform.md)
+* [Math Operators](func_groups/math_operators.md)
 
-#### [Overlap Studies](func_groups/overlap_studies.html)
+#### [Overlap Studies](func_groups/overlap_studies.md)
 
 ```
 BBANDS               Bollinger Bands
@@ -144,7 +144,7 @@ TRIMA                Triangular Moving Average
 WMA                  Weighted Moving Average
 ```
 
-#### [Momentum Indicators](func_groups/momentum_indicators.html)
+#### [Momentum Indicators](func_groups/momentum_indicators.md)
 
 ```
 ADX                  Average Directional Movement Index
@@ -179,7 +179,7 @@ ULTOSC               Ultimate Oscillator
 WILLR                Williams' %R
 ```
 
-#### [Volume Indicators](func_groups/volume_indicators.html)
+#### [Volume Indicators](func_groups/volume_indicators.md)
 
 ```
 AD                   Chaikin A/D Line
@@ -187,7 +187,7 @@ ADOSC                Chaikin A/D Oscillator
 OBV                  On Balance Volume
 ```
 
-#### [Volatility Indicators](func_groups/volatility_indicators.html)
+#### [Volatility Indicators](func_groups/volatility_indicators.md)
 
 ```
 ATR                  Average True Range
@@ -195,7 +195,7 @@ NATR                 Normalized Average True Range
 TRANGE               True Range
 ```
 
-#### [Price Transform](func_groups/price_transform.html)
+#### [Price Transform](func_groups/price_transform.md)
 
 ```
 AVGPRICE             Average Price
@@ -204,7 +204,7 @@ TYPPRICE             Typical Price
 WCLPRICE             Weighted Close Price
 ```
 
-#### [Cycle Indicators](func_groups/cycle_indicators.html)
+#### [Cycle Indicators](func_groups/cycle_indicators.md)
 
 ```
 HT_DCPERIOD          Hilbert Transform - Dominant Cycle Period
@@ -214,7 +214,7 @@ HT_SINE              Hilbert Transform - SineWave
 HT_TRENDMODE         Hilbert Transform - Trend vs Cycle Mode
 ```
 
-#### [Pattern Recognition](func_groups/pattern_recognition.html)
+#### [Pattern Recognition](func_groups/pattern_recognition.md)
 
 ```
 CDL2CROWS            Two Crows
@@ -280,7 +280,7 @@ CDLUPSIDEGAP2CROWS   Upside Gap Two Crows
 CDLXSIDEGAP3METHODS  Upside/Downside Gap Three Methods
 ```
 
-#### [Statistic Functions](func_groups/statistic_functions.html)
+#### [Statistic Functions](func_groups/statistic_functions.md)
 
 ```
 BETA                 Beta
diff --git a/docs/install.md b/docs/install.md
index 0b5d60c60..044e8271a 100644
--- a/docs/install.md
+++ b/docs/install.md
@@ -23,7 +23,7 @@ If you get build errors like this, it typically means that it can't find the
 underlying ``TA-Lib`` library and needs to be installed:
 
 # Dependencies
-To use TA-Lib for python, you need to have the [TA-Lib](http://ta-lib.org/hdr_dw.html)
+To use TA-Lib for python, you need to have the [TA-Lib](https://ta-lib.org/hdr_dw.html)
 already installed:
 
 #### Mac OS X
@@ -32,13 +32,14 @@ $ brew install ta-lib
 ```
 
 #### Windows
-Download [ta-lib-0.4.0-msvc.zip](http://prdownloads.sourceforge.net/ta-lib/ta-lib-0.4.0-msvc.zip)
+Download [ta-lib-0.4.0-msvc.zip](https://prdownloads.sourceforge.net/ta-lib/ta-lib-0.4.0-msvc.zip)
 and unzip to ``C:\ta-lib``
 
 #### Linux
-Download [ta-lib-0.4.0-src.tar.gz](http://prdownloads.sourceforge.net/ta-lib/ta-lib-0.4.0-src.tar.gz) and:
+Download [ta-lib-0.4.0-src.tar.gz](https://prdownloads.sourceforge.net/ta-lib/ta-lib-0.4.0-src.tar.gz) and:
 ```
-$ untar and cd
+$ tar zxvf ta-lib-0.4.0-src.tar.gz
+$ cd ta-lib
 $ ./configure --prefix=/usr
 $ make
 $ sudo make install
@@ -47,5 +48,5 @@ $ sudo make install
 > If you build ``TA-Lib`` using ``make -jX`` it will fail but that's OK!
 > Simply rerun ``make -jX`` followed by ``[sudo] make install``.
 
-[Documentation Index](doc_index.html)
-[FLOAT_RIGHTNext: Using the Function API](func.html)
+[Documentation Index](doc_index.md)
+[FLOAT_RIGHTNext: Using the Function API](func.md)
diff --git a/pyproject.toml b/pyproject.toml
new file mode 100644
index 000000000..6083626b6
--- /dev/null
+++ b/pyproject.toml
@@ -0,0 +1,44 @@
+[build-system]
+requires = ["setuptools", "wheel", "Cython", "numpy"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "TA-Lib"
+version = "0.6.9"
+description = "Python wrapper for TA-Lib"
+readme = "README.md"
+license-files = ["LICENSE"]
+authors = [
+    {name = "John Benediktsson", email = "mrjbq7@gmail.com"}
+]
+urls = {homepage = "http://github.com/ta-lib/ta-lib-python", download = "https://github.com/ta-lib/ta-lib-python/releases"}
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Operating System :: Unix",
+    "Operating System :: POSIX",
+    "Operating System :: MacOS :: MacOS X",
+    "Operating System :: Microsoft :: Windows",
+    "Programming Language :: Python",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Programming Language :: Cython",
+    "Topic :: Office/Business :: Financial",
+    "Topic :: Scientific/Engineering :: Mathematics",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Science/Research",
+    "Intended Audience :: Financial and Insurance Industry",
+]
+dependencies = [
+    "build",
+    "numpy",
+]
+requires-python = '>=3.9'
+
+[tool.setuptools]
+packages = ["talib"]
+package-data = {"talib" = ["_ta_lib.pyi", "py.typed"]}
diff --git a/requirements.txt b/requirements.txt
index 91aae4ee6..70bf4e3ba 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,2 +1,2 @@
-numpy==1.14.0
-Cython==0.27.3
+numpy
+Cython
diff --git a/requirements_dev.txt b/requirements_dev.txt
index 53897e7d5..3a6c0a909 100644
--- a/requirements_dev.txt
+++ b/requirements_dev.txt
@@ -1,4 +1,6 @@
 -r requirements.txt
-beautifulsoup4==4.6.0
-mistune==0.8.3
-Pygments==2.2.0
+beautifulsoup4
+mistune
+Pygments
+build
+cython
diff --git a/requirements_test.txt b/requirements_test.txt
index ad95355b9..144e7c76c 100644
--- a/requirements_test.txt
+++ b/requirements_test.txt
@@ -1,2 +1,4 @@
 -r requirements.txt
-pandas==0.22.0
+pandas
+pytest
+polars
diff --git a/setup.py b/setup.py
index 4ed0c1293..874983353 100644
--- a/setup.py
+++ b/setup.py
@@ -2,75 +2,64 @@
 
 import sys
 import os
+import os.path
 import warnings
 
-from distutils.dist import Distribution
+from setuptools import setup, Extension
 
-display_option_names = Distribution.display_option_names + ['help', 'help-commands']
-query_only = any('--' + opt in sys.argv for opt in display_option_names) or len(sys.argv) < 2 or sys.argv[1] == 'egg_info'
+import numpy
 
-try:
-    from setuptools import setup, Extension
-    requires = {"install_requires": ["numpy"]}
-except:
-    from distutils.core import setup
-    from distutils.extension import Extension
-    requires = {"requires": ["numpy"]}
+platform_supported = False
 
-lib_talib_name = 'ta_lib'  # the underlying C library's name
+lib_talib_name = 'ta-lib'               # the name as of TA-Lib 0.6.1
 
-runtime_lib_dirs = []
+if any(s in sys.platform for s in ['darwin', 'linux', 'bsd', 'sunos']):
+    platform_supported = True
+    include_dirs = [
+        '/usr/include',
+        '/usr/local/include',
+        '/opt/include',
+        '/opt/local/include',
+        '/opt/homebrew/include',
+        '/opt/homebrew/opt/ta-lib/include',
+    ]
+    library_dirs = [
+        '/usr/lib',
+        '/usr/local/lib',
+        '/usr/lib64',
+        '/usr/local/lib64',
+        '/opt/lib',
+        '/opt/local/lib',
+        '/opt/homebrew/lib',
+        '/opt/homebrew/opt/ta-lib/lib',
+    ]
 
-platform_supported = False
-for prefix in ['darwin', 'linux', 'bsd', 'sunos']:
-    if prefix in sys.platform:
-        platform_supported = True
-        include_dirs = [
-            '/usr/include',
-            '/usr/local/include',
-            '/opt/include',
-            '/opt/local/include',
-        ]
-        if 'TA_INCLUDE_PATH' in os.environ:
-            include_dirs.append(os.environ['TA_INCLUDE_PATH'])
-        lib_talib_dirs = [
-            '/usr/lib',
-            '/usr/local/lib',
-            '/usr/lib64',
-            '/usr/local/lib64',
-            '/opt/lib',
-            '/opt/local/lib',
-        ]
-        if 'TA_LIBRARY_PATH' in os.environ:
-            runtime_lib_dirs = os.environ['TA_LIBRARY_PATH']
-            if runtime_lib_dirs:
-                runtime_lib_dirs = runtime_lib_dirs.split(os.pathsep)
-                lib_talib_dirs.extend(runtime_lib_dirs)
-        break
-
-if sys.platform == "win32":
+elif sys.platform == "win32":
     platform_supported = True
-    lib_talib_name = 'ta_libc_cdr'
-    include_dirs = [r"c:\ta-lib\c\include"]
-    lib_talib_dirs = [r"c:\ta-lib\c\lib"]
+    lib_talib_name = 'ta-lib-static'
+    include_dirs = [
+        r"c:\ta-lib\c\include",
+        r"c:\Program Files\TA-Lib\include",
+        r"c:\Program Files (x86)\TA-Lib\include",
+    ]
+    library_dirs = [
+        r"c:\ta-lib\c\lib",
+        r"c:\Program Files\TA-Lib\lib",
+        r"c:\Program Files (x86)\TA-Lib\lib",
+    ]
 
-if not platform_supported:
-    raise NotImplementedError(sys.platform)
+if 'TA_INCLUDE_PATH' in os.environ:
+    include_dirs = os.environ['TA_INCLUDE_PATH'].split(os.pathsep)
 
-# Do not require numpy or cython for just querying the package
-if not query_only:
-    import numpy
-    include_dirs.insert(0, numpy.get_include())
+if 'TA_LIBRARY_PATH' in os.environ:
+    library_dirs = os.environ['TA_LIBRARY_PATH'].split(os.pathsep)
 
-try:
-    from Cython.Distutils import build_ext
-    has_cython = True
-except ImportError:
-    has_cython = False
+if not platform_supported:
+    raise NotImplementedError(sys.platform)
 
-for lib_talib_dir in lib_talib_dirs:
+for path in library_dirs:
     try:
-        files = os.listdir(lib_talib_dir)
+        files = os.listdir(path)
         if any(lib_talib_name in f for f in files):
             break
     except OSError:
@@ -78,52 +67,42 @@
 else:
     warnings.warn('Cannot find ta-lib library, installation may fail.')
 
-cmdclass = {}
-if has_cython:
-    cmdclass['build_ext'] = build_ext
+# Get the Cython build_ext or fall back to setuptools build_ext
+try:
+    from Cython.Distutils import build_ext
+    has_cython = True
+except ImportError:
+    from setuptools.command.build_ext import build_ext
+    has_cython = False
+
+class NumpyBuildExt(build_ext):
+    """
+    Custom build_ext command that adds numpy's include_dir to extensions.
+    """
+
+    def build_extensions(self):
+        """
+        Add numpy's include directory to Extension includes.
+        """
+        numpy_incl = numpy.get_include()
+        for ext in self.extensions:
+            ext.include_dirs.append(numpy_incl)
+
+        super().build_extensions()
+
+cmdclass = {'build_ext': NumpyBuildExt}
 
 ext_modules = [
     Extension(
         'talib._ta_lib',
         ['talib/_ta_lib.pyx' if has_cython else 'talib/_ta_lib.c'],
         include_dirs=include_dirs,
-        library_dirs=lib_talib_dirs,
+        library_dirs=library_dirs,
         libraries=[lib_talib_name],
-        runtime_library_dirs=runtime_lib_dirs
-    )
+        runtime_library_dirs=[] if sys.platform == 'win32' else library_dirs)
 ]
 
 setup(
-    name = 'TA-Lib',
-    version = '0.4.18',
-    description = 'Python wrapper for TA-Lib',
-    author = 'John Benediktsson',
-    author_email = 'mrjbq7@gmail.com',
-    url = 'http://github.com/mrjbq7/ta-lib',
-    download_url = 'https://github.com/mrjbq7/ta-lib/releases',
-    classifiers = [
-        "License :: OSI Approved :: BSD License",
-        "Development Status :: 4 - Beta",
-        "Operating System :: Unix",
-        "Operating System :: POSIX",
-        "Operating System :: MacOS :: MacOS X",
-        "Operating System :: Microsoft :: Windows",
-        "Programming Language :: Python",
-        "Programming Language :: Python :: 2.7",
-        "Programming Language :: Python :: 3.3",
-        "Programming Language :: Python :: 3.4",
-        "Programming Language :: Python :: 3.5",
-        "Programming Language :: Python :: 3.6",
-        "Programming Language :: Python :: 3.7",
-        "Programming Language :: Cython",
-        "Topic :: Office/Business :: Financial",
-        "Topic :: Scientific/Engineering :: Mathematics",
-        "Intended Audience :: Developers",
-        "Intended Audience :: Science/Research",
-        "Intended Audience :: Financial and Insurance Industry",
-    ],
-    packages = ['talib'],
-    ext_modules = ext_modules,
-    cmdclass = cmdclass,
-    **requires
+    ext_modules=ext_modules,
+    cmdclass=cmdclass,
 )
diff --git a/talib/__init__.py b/talib/__init__.py
index 05b0f5deb..c2df327d1 100644
--- a/talib/__init__.py
+++ b/talib/__init__.py
@@ -3,45 +3,108 @@
 from itertools import chain
 from functools import wraps
 
+# If polars is available, wrap talib functions so that they support
+# polars.Series input
+try:
+    from polars import Series as _pl_Series
+except ImportError as import_error:
+    try:
+        if not isinstance(import_error, ModuleNotFoundError) or import_error.name != 'polars':
+            # Propagate the error when the module exists but failed to be imported.
+            raise import_error
+    # `ModuleNotFoundError` was introduced in Python 3.6.
+    except NameError:
+        pass
+
+    # polars not available, nothing to wrap
+    _pl_Series = None
+
 # If pandas is available, wrap talib functions so that they support
 # pandas.Series input
 try:
     from pandas import Series as _pd_Series
-except ImportError:
+except ImportError as import_error:
+    try:
+        if not isinstance(import_error, ModuleNotFoundError) or import_error.name != 'pandas':
+            # Propagate the error when the module exists but failed to be imported.
+            raise import_error
+    # `ModuleNotFoundError` was introduced in Python 3.6.
+    except NameError:
+        pass
+
     # pandas not available, nothing to wrap
-    _pandas_wrapper = lambda x: x
-else:
-    def _pandas_wrapper(func):
+    _pd_Series = None
+
+if _pl_Series is not None or _pd_Series is not None:
+
+    def _wrapper(func):
         @wraps(func)
-        def wrapper(*args, **kwargs):
-            try:
-                # Get the index of the first Series object, if any
+        def wrapper(*args, **kwds):
+
+            if _pl_Series is not None:
+                use_pl = any(isinstance(arg, _pl_Series) for arg in args) or \
+                         any(isinstance(v, _pl_Series) for v in kwds.values())
+            else:
+                use_pl = False
+
+            if _pd_Series is not None:
+                use_pd = any(isinstance(arg, _pd_Series) for arg in args) or \
+                         any(isinstance(v, _pd_Series) for v in kwds.values())
+            else:
+                use_pd = False
+
+            if use_pl and use_pd:
+                raise Exception("Cannot mix polars and pandas")
+
+            # Use float64 values if polars or pandas, else use values as passed
+            if use_pl:
+                _args = [arg.to_numpy().astype(float) if isinstance(arg, _pl_Series) else
+                         arg for arg in args]
+                _kwds = {k: v.to_numpy().astype(float) if isinstance(v, _pl_Series) else
+                            v for k, v in kwds.items()}
+
+            elif use_pd:
                 index = next(arg.index
-                             for arg in chain(args, kwargs.values())
+                             for arg in chain(args, kwds.values())
                              if isinstance(arg, _pd_Series))
-            except StopIteration:
-                # No pandas.Series passed in; short-circuit
-                index = None
 
-            if index is None:
-                return func(*args, **kwargs)
+                _args = [arg.to_numpy().astype(float) if isinstance(arg, _pd_Series) else
+                         arg for arg in args]
+                _kwds = {k: v.to_numpy().astype(float) if isinstance(v, _pd_Series) else
+                            v for k, v in kwds.items()}
+
+            else:
+                _args = args
+                _kwds = kwds
+
+            result = func(*_args, **_kwds)
+
+            # check to see if we got a streaming result
+            first_result = result[0] if isinstance(result, tuple) else result
+            is_streaming_fn_result = not hasattr(first_result, '__len__')
+            if is_streaming_fn_result:
+                return result
 
-            # Use Series' float64 values if pandas, else use values as passed
-            args = [arg.values.astype(float) if isinstance(arg, _pd_Series) else arg
-                    for arg in args]
-            kwargs = {k: v.values.astype(float) if isinstance(v, _pd_Series) else v
-                      for k, v in kwargs.items()}
+            # Series was passed in, Series gets out
+            if use_pl:
+                if isinstance(result, tuple):
+                    return tuple(_pl_Series(arr) for arr in result)
+                else:
+                    return _pl_Series(result)
 
-            result = func(*args, **kwargs)
+            elif use_pd:
+                if isinstance(result, tuple):
+                    return tuple(_pd_Series(arr, index=index) for arr in result)
+                else:
+                    return _pd_Series(result, index=index)
 
-            # Series was passed in, Series gets out; re-apply index
-            if isinstance(result, tuple):
-                # Handle multi-array results such as BBANDS
-                return tuple(_pd_Series(arr, index=index)
-                             for arr in result)
-            return _pd_Series(result, index=index)
+            else:
+                return result
 
         return wrapper
+else:
+    _wrapper = lambda x: x
+
 
 from ._ta_lib import (
     _ta_initialize, _ta_shutdown, MA_Type, __ta_version__,
@@ -52,17 +115,28 @@ def wrapper(*args, **kwargs):
     __TA_FUNCTION_NAMES__
 )
 
+# import all the func and stream functions
+from ._ta_lib import *
+
+# wrap them for polars or pandas support
 func = __import__("_ta_lib", globals(), locals(), __TA_FUNCTION_NAMES__, level=1)
 for func_name in __TA_FUNCTION_NAMES__:
-    wrapped_func = _pandas_wrapper(getattr(func, func_name))
+    wrapped_func = _wrapper(getattr(func, func_name))
     setattr(func, func_name, wrapped_func)
     globals()[func_name] = wrapped_func
 
-__version__ = '0.4.18'
+stream_func_names = ['stream_%s' % fname for fname in __TA_FUNCTION_NAMES__]
+stream = __import__("stream", globals(), locals(), stream_func_names, level=1)
+for func_name, stream_func_name in zip(__TA_FUNCTION_NAMES__, stream_func_names):
+    wrapped_func = _wrapper(getattr(stream, func_name))
+    setattr(stream, func_name, wrapped_func)
+    globals()[stream_func_name] = wrapped_func
+
+__version__ = '0.6.9'
 
 # In order to use this python library, talib (i.e. this __file__) will be
 # imported at some point, either explicitly or indirectly via talib.func
-# or talib.abstract. Here, we handle initalizing and shutting down the
+# or talib.abstract. Here, we handle initializing and shutting down the
 # underlying TA-Lib. Initialization happens on import, before any other TA-Lib
 # functions are called. Finally, when the python process exits, we shutdown
 # the underlying TA-Lib.
@@ -118,6 +192,7 @@ def wrapper(*args, **kwargs):
         'CCI',
         'CMO',
         'DX',
+        'IMI',
         'MACD',
         'MACDEXT',
         'MACDFIX',
@@ -141,6 +216,7 @@ def wrapper(*args, **kwargs):
         'WILLR',
         ],
     'Overlap Studies': [
+        'ACCBANDS',
         'BBANDS',
         'DEMA',
         'EMA',
@@ -223,6 +299,7 @@ def wrapper(*args, **kwargs):
         'CDLXSIDEGAP3METHODS',
         ],
     'Price Transform': [
+        'AVGDEV',
         'AVGPRICE',
         'MEDPRICE',
         'TYPPRICE',
@@ -267,4 +344,4 @@ def get_function_groups():
     """
     return __function_groups__.copy()
 
-__all__ = ['get_functions', 'get_function_groups']
+__all__ = ['get_functions', 'get_function_groups'] + __TA_FUNCTION_NAMES__ + ["stream_%s" % name for name in __TA_FUNCTION_NAMES__]
diff --git a/talib/_abstract.pxi b/talib/_abstract.pxi
index 6bd0003eb..6989ab80d 100644
--- a/talib/_abstract.pxi
+++ b/talib/_abstract.pxi
@@ -2,6 +2,7 @@
 This file Copyright (c) 2013 Brian A Cappello <briancappello at gmail>
 '''
 import math
+import threading
 try:
     from collections import OrderedDict
 except ImportError: # handle python 2.6 and earlier
@@ -14,13 +15,7 @@ cimport numpy as np
 cimport _ta_lib as lib
 # NOTE: _ta_check_success, MA_Type is defined in _common.pxi
 
-
-__INPUT_ARRAYS_DEFAULTS = {'open':   None,
-                           'high':   None,
-                           'low':    None,
-                           'close':  None,
-                           'volume': None,
-                           }
+np.import_array() # Initialize the NumPy C API
 
 # lookup for TALIB input parameters which don't define expected price series inputs
 __INPUT_PRICE_SERIES_DEFAULTS = {'price':   'close',
@@ -29,19 +24,51 @@ __INPUT_PRICE_SERIES_DEFAULTS = {'price':   'close',
                                  'periods': 'periods', # only used by MAVP; not a price series!
                                  }
 
+__INPUT_ARRAYS_TYPES = [dict]
+__ARRAY_TYPES = [np.ndarray]
+
 # allow use of pandas.DataFrame for input arrays
 try:
     import pandas
-    __INPUT_ARRAYS_TYPES = (dict, pandas.DataFrame)
-    __ARRAY_TYPES = (np.ndarray, pandas.Series)
+    __INPUT_ARRAYS_TYPES.append(pandas.DataFrame)
+    __ARRAY_TYPES.append(pandas.Series)
     __PANDAS_DATAFRAME = pandas.DataFrame
     __PANDAS_SERIES = pandas.Series
-except ImportError:
-    __INPUT_ARRAYS_TYPES = (dict,)
-    __ARRAY_TYPES = (np.ndarray,)
+except ImportError as import_error:
+    try:
+        if not isinstance(import_error, ModuleNotFoundError) or import_error.name != 'pandas':
+            # Propagate the error when the module exists but failed to be imported.
+            raise import_error
+    # `ModuleNotFoundError` was introduced in Python 3.6.
+    except NameError:
+        pass
+
     __PANDAS_DATAFRAME = None
     __PANDAS_SERIES = None
 
+# allow use of polars.DataFrame for input arrays
+try:
+    import polars
+    __INPUT_ARRAYS_TYPES.append(polars.DataFrame)
+    __ARRAY_TYPES.append(polars.Series)
+    __POLARS_DATAFRAME = polars.DataFrame
+    __POLARS_SERIES = polars.Series
+except ImportError as import_error:
+    try:
+        if not isinstance(import_error, ModuleNotFoundError) or import_error.name != 'polars':
+            # Propagate the error when the module exists but failed to be imported.
+            raise import_error
+    # `ModuleNotFoundError` was introduced in Python 3.6.
+    except NameError:
+        pass
+
+    __POLARS_DATAFRAME = None
+    __POLARS_SERIES = None
+
+__INPUT_ARRAYS_TYPES = tuple(__INPUT_ARRAYS_TYPES)
+__ARRAY_TYPES = tuple(__ARRAY_TYPES)
+
+
 if sys.version >= '3':
 
     def str2bytes(s):
@@ -64,10 +91,10 @@ class Function(object):
     intended to simplify using individual TALIB functions by providing a
     unified interface for setting/controlling input data, setting function
     parameters and retrieving results. Input data consists of a ``dict`` of
-    ``numpy`` arrays (or a ``pandas.DataFrame``), one array for each of open,
-    high, low, close and volume. This can be set with the set_input_arrays()
-    method. Which keyed array(s) are used as inputs when calling the function
-    is controlled using the input_names property.
+    ``numpy`` arrays (or a ``pandas.DataFrame`` or ``polars.DataFrame``), one
+    array for each of open, high, low, close and volume. This can be set with
+    the set_input_arrays() method. Which keyed array(s) are used as inputs when
+    calling the function is controlled using the input_names property.
 
     This class gets initialized with a TALIB function name and optionally an
     input_arrays object. It provides the following primary functions for
@@ -78,7 +105,7 @@ class Function(object):
     - set_function_args([input_arrays,] [param_args_andor_kwargs])
 
     Documentation for param_args_andor_kwargs can be seen by printing the
-    Function instance or programatically via the info, input_names and
+    Function instance or programmatically via the info, input_names and
     parameters properties.
 
     ----- result-returning functions -----
@@ -92,88 +119,97 @@ class Function(object):
         self.__name = function_name.upper()
         self.__namestr = self.__name
         self.__name = str2bytes(self.__name)
-        self.__info = None
-        self.__input_arrays = __INPUT_ARRAYS_DEFAULTS
 
-        # dictionaries of function args. keys are input/opt_input/output parameter names
-        self.__input_names = OrderedDict()
-        self.__opt_inputs = OrderedDict()
-        self.__outputs = OrderedDict()
-        self.__outputs_valid = False
+        # thread-local storage
+        self.__localdata = threading.local()
 
         # finish initializing: query the TALIB abstract interface and set arguments
-        self.__initialize_function_info()
         self.set_function_args(*args, **kwargs)
         self.func_object = func_object
 
-    def __initialize_function_info(self):
-        # function info
-        self.__info = _ta_getFuncInfo(self.__name)
-
-        # inputs (price series names)
-        for i in xrange(self.__info.pop('num_inputs')):
-            info = _ta_getInputParameterInfo(self.__name, i)
-            input_name = info['name']
-            if info['price_series'] is None:
-                info['price_series'] = __INPUT_PRICE_SERIES_DEFAULTS[input_name]
-            self.__input_names[input_name] = info
-        self.__info['input_names'] = self.input_names
-
-        # optional inputs (function parameters)
-        for i in xrange(self.__info.pop('num_opt_inputs')):
-            info = _ta_getOptInputParameterInfo(self.__name, i)
-            param_name = info['name']
-            self.__opt_inputs[param_name] = info
-        self.__info['parameters'] = self.parameters
-
-        # outputs
-        self.__info['output_flags'] = OrderedDict()
-        for i in xrange(self.__info.pop('num_outputs')):
-            info = _ta_getOutputParameterInfo(self.__name, i)
-            output_name = info['name']
-            self.__info['output_flags'][output_name] = info['flags']
-            self.__outputs[output_name] = None
-        self.__info['output_names'] = self.output_names
+    @property
+    def __local(self):
+        local = self.__localdata
+        if not hasattr(local, 'info'):
+            local.info = None
+            local.input_arrays = {}
+
+            # dictionaries of function args. keys are input/opt_input/output parameter names
+            local.input_names = OrderedDict()
+            local.opt_inputs = OrderedDict()
+            local.outputs = OrderedDict()
+            local.outputs_valid = False
+
+            # function info
+            local.info = _ta_getFuncInfo(self.__name)
+
+            # inputs (price series names)
+            for i in xrange(local.info.pop('num_inputs')):
+                info = _ta_getInputParameterInfo(self.__name, i)
+                input_name = info['name']
+                if info['price_series'] is None:
+                    info['price_series'] = __INPUT_PRICE_SERIES_DEFAULTS[input_name]
+                local.input_names[input_name] = info
+            local.info['input_names'] = self.input_names
+
+            # optional inputs (function parameters)
+            for i in xrange(local.info.pop('num_opt_inputs')):
+                info = _ta_getOptInputParameterInfo(self.__name, i)
+                param_name = info['name']
+                local.opt_inputs[param_name] = info
+            local.info['parameters'] = self.parameters
+
+            # outputs
+            local.info['output_flags'] = OrderedDict()
+            for i in xrange(local.info.pop('num_outputs')):
+                info = _ta_getOutputParameterInfo(self.__name, i)
+                output_name = info['name']
+                local.info['output_flags'][output_name] = info['flags']
+                local.outputs[output_name] = None
+            local.info['output_names'] = self.output_names
+        return local
 
     @property
     def info(self):
         """
         Returns a copy of the function's info dict.
         """
-        return self.__info.copy()
+        return self.__local.info.copy()
 
     @property
     def function_flags(self):
         """
         Returns any function flags defined for this indicator function.
         """
-        return self.__info['function_flags']
+        return self.__local.info['function_flags']
 
     @property
     def output_flags(self):
         """
         Returns the flags for each output for this indicator function.
         """
-        return self.__info['output_flags'].copy()
+        return self.__local.info['output_flags'].copy()
 
     def get_input_names(self):
         """
         Returns the dict of input price series names that specifies which
         of the ndarrays in input_arrays will be used to calculate the function.
         """
+        local = self.__local
         ret = OrderedDict()
-        for input_name in self.__input_names:
-            ret[input_name] = self.__input_names[input_name]['price_series']
+        for input_name in local.input_names:
+            ret[input_name] = local.input_names[input_name]['price_series']
         return ret
 
     def set_input_names(self, input_names):
         """
         Sets the input price series names to use.
         """
+        local = self.__local
         for input_name, price_series in input_names.items():
-            self.__input_names[input_name]['price_series'] = price_series
-            self.__info['input_names'][input_name] = price_series
-        self.__outputs_valid = False
+            local.input_names[input_name]['price_series'] = price_series
+            local.info['input_names'][input_name] = price_series
+        local.outputs_valid = False
 
     input_names = property(get_input_names, set_input_names)
 
@@ -181,7 +217,12 @@ class Function(object):
         """
         Returns a copy of the dict of input arrays in use.
         """
-        return self.__input_arrays.copy()
+        local = self.__local
+        if __POLARS_DATAFRAME is not None \
+            and isinstance(local.input_arrays, __POLARS_DATAFRAME):
+            return local.input_arrays.clone()
+        else:
+            return local.input_arrays.copy()
 
     def set_input_arrays(self, input_arrays):
         """
@@ -208,14 +249,20 @@ class Function(object):
                     return True
                 return False
         """
+        local = self.__local
         if isinstance(input_arrays, __INPUT_ARRAYS_TYPES):
             missing_keys = []
             for key in self.__input_price_series_names():
-                if key not in input_arrays:
+                if __POLARS_DATAFRAME is not None \
+                    and isinstance(input_arrays, __POLARS_DATAFRAME):
+                    missing = key not in input_arrays.columns
+                else:
+                    missing = key not in input_arrays
+                if missing:
                     missing_keys.append(key)
             if len(missing_keys) == 0:
-                self.__input_arrays = input_arrays
-                self.__outputs_valid = False
+                local.input_arrays = input_arrays
+                local.outputs_valid = False
                 return True
             else:
                 raise Exception('input_arrays parameter missing required data '\
@@ -230,8 +277,9 @@ class Function(object):
         """
         Returns the function's optional parameters and their default values.
         """
+        local = self.__local
         ret = OrderedDict()
-        for opt_input in self.__opt_inputs:
+        for opt_input in local.opt_inputs:
             ret[opt_input] = self.__get_opt_input_value(opt_input)
         return ret
 
@@ -239,13 +287,14 @@ class Function(object):
         """
         Sets the function parameter values.
         """
+        local = self.__local
         parameters = parameters or {}
         parameters.update(kwargs)
         for param, value in parameters.items():
             if self.__check_opt_input_value(param, value):
-                self.__opt_inputs[param]['value'] = value
-        self.__outputs_valid = False
-        self.__info['parameters'] = self.parameters
+                local.opt_inputs[param]['value'] = value
+        local.outputs_valid = False
+        local.info['parameters'] = self.parameters
 
     parameters = property(get_parameters, set_parameters)
 
@@ -253,35 +302,36 @@ class Function(object):
         """
         optional args:[input_arrays,] [parameter_args,] [input_price_series_kwargs,] [parameter_kwargs]
         """
+        local = self.__local
         update_info = False
 
         for key in kwargs:
-            if key in self.__opt_inputs:
+            if key in local.opt_inputs:
                 value = kwargs[key]
                 if self.__check_opt_input_value(key, value):
-                    self.__opt_inputs[key]['value'] = kwargs[key]
+                    local.opt_inputs[key]['value'] = kwargs[key]
                     update_info = True
-            elif key in self.__input_names:
-                self.__input_names[key]['price_series'] = kwargs[key]
-                self.__info['input_names'][key] = kwargs[key]
+            elif key in local.input_names:
+                local.input_names[key]['price_series'] = kwargs[key]
+                local.info['input_names'][key] = kwargs[key]
 
         if args:
             skip_first = 0
             if self.set_input_arrays(args[0]):
                 skip_first = 1
             if len(args) > skip_first:
-                for i, param_name in enumerate(self.__opt_inputs):
+                for i, param_name in enumerate(local.opt_inputs):
                     i += skip_first
                     if i < len(args):
                         value = args[i]
                         if self.__check_opt_input_value(param_name, value):
-                            self.__opt_inputs[param_name]['value'] = value
+                            local.opt_inputs[param_name]['value'] = value
                             update_info = True
 
         if args or kwargs:
             if update_info:
-                self.__info['parameters'] = self.parameters
-            self.__outputs_valid = False
+                local.info['parameters'] = self.parameters
+            local.outputs_valid = False
 
     @property
     def lookback(self):
@@ -289,11 +339,12 @@ class Function(object):
         Returns the lookback window size for the function with the parameter
         values that are currently set.
         """
+        local = self.__local
         cdef lib.TA_ParamHolder *holder
         holder = __ta_paramHolderAlloc(self.__name)
-        for i, opt_input in enumerate(self.__opt_inputs):
+        for i, opt_input in enumerate(local.opt_inputs):
             value = self.__get_opt_input_value(opt_input)
-            type_ = self.__opt_inputs[opt_input]['type']
+            type_ = local.opt_inputs[opt_input]['type']
             if type_ == lib.TA_OptInput_RealRange or type_ == lib.TA_OptInput_RealList:
                 __ta_setOptInputParamReal(holder, i, value)
             elif type_ == lib.TA_OptInput_IntegerRange or type_ == lib.TA_OptInput_IntegerList:
@@ -308,7 +359,7 @@ class Function(object):
         """
         Returns a list of the output names returned by this function.
         """
-        ret = self.__outputs.keys()
+        ret = self.__local.outputs.keys()
         if not isinstance(ret, list):
             ret = list(ret)
         return ret
@@ -320,20 +371,28 @@ class Function(object):
         parameters. Returned values are a ndarray if there is only one output
         or a list of ndarrays for more than one output.
         """
-        if not self.__outputs_valid:
+        local = self.__local
+        if not local.outputs_valid:
             self.__call_function()
-        ret = self.__outputs.values()
+        ret = local.outputs.values()
         if not isinstance(ret, list):
             ret = list(ret)
         if __PANDAS_DATAFRAME is not None and \
-                isinstance(self.__input_arrays, __PANDAS_DATAFRAME):
-            index = self.__input_arrays.index
+                isinstance(local.input_arrays, __PANDAS_DATAFRAME):
+            index = local.input_arrays.index
             if len(ret) == 1:
                 return __PANDAS_SERIES(ret[0], index=index)
             else:
                 return __PANDAS_DATAFRAME(numpy.column_stack(ret),
                                           index=index,
                                           columns=self.output_names)
+        elif __POLARS_DATAFRAME is not None and \
+                isinstance(local.input_arrays, __POLARS_DATAFRAME):
+            if len(ret) == 1:
+                return __POLARS_SERIES(ret[0])
+            else:
+                return __POLARS_DATAFRAME(numpy.column_stack(ret),
+                                          schema=self.output_names)
         else:
             return ret[0] if len(ret) == 1 else ret
 
@@ -356,9 +415,12 @@ class Function(object):
         This is a shortcut to the outputs property that also allows setting
         the input_arrays dict and function parameters.
         """
+        local = self.__local
         # do not cache ta-func parameters passed to __call__
-        opt_input_values = [(param_name, self.__opt_inputs[param_name]['value'])
-                            for param_name in self.__opt_inputs.keys()]
+        opt_input_values = [(param_name, local.opt_inputs[param_name]['value'])
+                            for param_name in local.opt_inputs.keys()]
+        price_series_name_values = [(n, local.input_names[n]['price_series'])
+                                    for n in local.input_names]
 
         # allow calling with same signature as talib.func module functions
         args = list(args)
@@ -377,10 +439,19 @@ class Function(object):
                         ', '.join(input_price_series_names))
                     raise TypeError(msg)
 
+        if __PANDAS_DATAFRAME is not None \
+                and isinstance(local.input_arrays, __PANDAS_DATAFRAME):
+            no_existing_input_arrays = local.input_arrays.empty
+        elif __POLARS_DATAFRAME is not None \
+                and isinstance(local.input_arrays, __POLARS_DATAFRAME):
+            no_existing_input_arrays = local.input_arrays.is_empty()
+        else:
+            no_existing_input_arrays = not bool(local.input_arrays)
+
         if len(input_arrays) == len(input_price_series_names):
             self.set_input_arrays(input_arrays)
             args = args[len(input_arrays):]
-        elif len(input_arrays) or (not self.__input_arrays and (
+        elif len(input_arrays) or (no_existing_input_arrays and (
                 not len(args) or not isinstance(args[0], __INPUT_ARRAYS_TYPES))):
             msg = 'Not enough price arguments: expected %d (%s)' % (
                 len(input_price_series_names),
@@ -392,15 +463,22 @@ class Function(object):
 
         # restore opt_input values to as they were before this call
         for param_name, value in opt_input_values:
-            self.__opt_inputs[param_name]['value'] = value
+            local.opt_inputs[param_name]['value'] = value
+        local.info['parameters'] = self.parameters
+
+        # restore input names values to as they were before this call
+        for input_name, value in price_series_name_values:
+            local.input_names[input_name]['price_series'] = value
+            local.info['input_names'][input_name] = value
 
         return self.outputs
 
     # figure out which price series names we're using for inputs
     def __input_price_series_names(self):
+        local = self.__local
         input_price_series_names = []
-        for input_name in self.__input_names:
-            price_series = self.__input_names[input_name]['price_series']
+        for input_name in local.input_names:
+            price_series = local.input_names[input_name]['price_series']
             if isinstance(price_series, list): # TALIB-supplied input names
                 for name in price_series:
                     input_price_series_names.append(name)
@@ -409,34 +487,38 @@ class Function(object):
         return input_price_series_names
 
     def __call_function(self):
+        local = self.__local
         input_price_series_names = self.__input_price_series_names()
 
         # populate the ordered args we'll call the function with
         args = []
         for price_series in input_price_series_names:
-            series = self.__input_arrays[price_series]
+            series = local.input_arrays[price_series]
             if __PANDAS_SERIES is not None and \
                     isinstance(series, __PANDAS_SERIES):
                 series = series.values.astype(float)
+            elif __POLARS_SERIES is not None and \
+                    isinstance(series, __POLARS_SERIES):
+                series = series.to_numpy().astype(float)
             args.append(series)
-        for opt_input in self.__opt_inputs:
+        for opt_input in local.opt_inputs:
             value = self.__get_opt_input_value(opt_input)
             args.append(value)
 
         # Use the func module to actually call the function.
         results = self.func_object(*args)
         if isinstance(results, np.ndarray):
-            keys = self.__outputs.keys()
+            keys = local.outputs.keys()
             if not isinstance(keys, list):
                 keys = list(keys)
-            self.__outputs[keys[0]] = results
+            local.outputs[keys[0]] = results
         else:
-            for i, output in enumerate(self.__outputs):
-                self.__outputs[output] = results[i]
-        self.__outputs_valid = True
+            for i, output in enumerate(local.outputs):
+                local.outputs[output] = results[i]
+        local.outputs_valid = True
 
     def __check_opt_input_value(self, input_name, value):
-        type_ = self.__opt_inputs[input_name]['type']
+        type_ = self.__local.opt_inputs[input_name]['type']
         if type_ in {lib.TA_OptInput_IntegerList, lib.TA_OptInput_IntegerRange}:
             type_ = int
         elif type_ in {lib.TA_OptInput_RealList, lib.TA_OptInput_RealRange}:
@@ -454,9 +536,10 @@ class Function(object):
         """
         Returns the user-set value if there is one, otherwise the default.
         """
-        value = self.__opt_inputs[input_name]['value']
+        local = self.__local
+        value = local.opt_inputs[input_name]['value']
         if value is None:
-            value = self.__opt_inputs[input_name]['default_value']
+            value = local.opt_inputs[input_name]['default_value']
         return value
 
     def __repr__(self):
@@ -567,7 +650,7 @@ def _ta_getFuncInfo(char *function_name):
     Returns the info dict for the function. It has the following keys: name,
     group, help, flags, num_inputs, num_opt_inputs and num_outputs.
     """
-    cdef lib.TA_FuncInfo *info
+    cdef const lib.TA_FuncInfo *info
     retCode = lib.TA_GetFuncInfo(__ta_getFuncHandle(function_name), &info)
     _ta_check_success('TA_GetFuncInfo', retCode)
 
@@ -586,7 +669,7 @@ def _ta_getInputParameterInfo(char *function_name, int idx):
     Returns the function's input info dict for the given index. It has two
     keys: name and flags.
     """
-    cdef lib.TA_InputParameterInfo *info
+    cdef const lib.TA_InputParameterInfo *info
     retCode = lib.TA_GetInputParameterInfo(__ta_getFuncHandle(function_name), idx, &info)
     _ta_check_success('TA_GetInputParameterInfo', retCode)
 
@@ -607,15 +690,13 @@ def _ta_getOptInputParameterInfo(char *function_name, int idx):
     Returns the function's opt_input info dict for the given index. It has the
     following keys: name, display_name, type, help, default_value and value.
     """
-    cdef lib.TA_OptInputParameterInfo *info
+    cdef const lib.TA_OptInputParameterInfo *info
     retCode = lib.TA_GetOptInputParameterInfo(__ta_getFuncHandle(function_name), idx, &info)
     _ta_check_success('TA_GetOptInputParameterInfo', retCode)
 
     name = bytes2str(info.paramName)
     name = name[len('optIn'):].lower()
-    default_value = info.defaultValue
-    if default_value % 1 == 0:
-        default_value = int(default_value)
+    default_value = int(info.defaultValue) if info.type > 1 else info.defaultValue
 
     return {
         'name': name,
@@ -631,7 +712,7 @@ def _ta_getOutputParameterInfo(char *function_name, int idx):
     Returns the function's output info dict for the given index. It has two
     keys: name and flags.
     """
-    cdef lib.TA_OutputParameterInfo *info
+    cdef const lib.TA_OutputParameterInfo *info
     retCode = lib.TA_GetOutputParameterInfo(__ta_getFuncHandle(function_name), idx, &info)
     _ta_check_success('TA_GetOutputParameterInfo', retCode)
 
@@ -698,11 +779,11 @@ def _get_defaults_and_docs(func_info):
 # - Getting TALIB handle and paramholder pointers
 # - Setting TALIB paramholder optInput values and calling the lookback function
 
-cdef lib.TA_FuncHandle*  __ta_getFuncHandle(char *function_name):
+cdef const lib.TA_FuncHandle*  __ta_getFuncHandle(char *function_name):
     """
     Returns a pointer to a function handle for the given function name
     """
-    cdef lib.TA_FuncHandle *handle
+    cdef const lib.TA_FuncHandle *handle
     _ta_check_success('TA_GetFuncHandle', lib.TA_GetFuncHandle(function_name, &handle))
     return handle
 
@@ -726,7 +807,7 @@ cdef int __ta_setOptInputParamInteger(lib.TA_ParamHolder *holder, int idx, int v
     retCode = lib.TA_SetOptInputParamInteger(holder, idx, value)
     _ta_check_success('TA_SetOptInputParamInteger', retCode)
 
-cdef int __ta_setOptInputParamReal(lib.TA_ParamHolder *holder, int idx, int value):
+cdef int __ta_setOptInputParamReal(lib.TA_ParamHolder *holder, int idx, double value):
     retCode = lib.TA_SetOptInputParamReal(holder, idx, value)
     _ta_check_success('TA_SetOptInputParamReal', retCode)
 
diff --git a/talib/_func.pxi b/talib/_func.pxi
index acc65903b..c4555a42c 100644
--- a/talib/_func.pxi
+++ b/talib/_func.pxi
@@ -22,7 +22,7 @@ cdef np.ndarray check_array(np.ndarray real):
         raise Exception("input array type is not double")
     if real.ndim != 1:
         raise Exception("input array has wrong dimensions")
-    if not (PyArray_FLAGS(real) & np.NPY_C_CONTIGUOUS):
+    if not (PyArray_FLAGS(real) & np.NPY_ARRAY_C_CONTIGUOUS):
         real = PyArray_GETCONTIGUOUS(real)
     return real
 
@@ -56,7 +56,7 @@ cdef np.npy_intp check_length4(np.ndarray a1, np.ndarray a2, np.ndarray a3, np.n
         raise Exception("input array lengths are different")
     return length
 
-cdef np.npy_int check_begidx1(np.npy_intp length, double* a1) except -1:
+cdef np.npy_int check_begidx1(np.npy_intp length, double* a1):
     cdef:
         double val
     for i from 0 <= i < length:
@@ -65,9 +65,9 @@ cdef np.npy_int check_begidx1(np.npy_intp length, double* a1) except -1:
             continue
         return i
     else:
-        raise Exception("inputs are all NaN")
+        return length - 1
 
-cdef np.npy_int check_begidx2(np.npy_intp length, double* a1, double* a2) except -1:
+cdef np.npy_int check_begidx2(np.npy_intp length, double* a1, double* a2):
     cdef:
         double val
     for i from 0 <= i < length:
@@ -79,9 +79,9 @@ cdef np.npy_int check_begidx2(np.npy_intp length, double* a1, double* a2) except
             continue
         return i
     else:
-        raise Exception("inputs are all NaN")
+        return length - 1
 
-cdef np.npy_int check_begidx3(np.npy_intp length, double* a1, double* a2, double* a3) except -1:
+cdef np.npy_int check_begidx3(np.npy_intp length, double* a1, double* a2, double* a3):
     cdef:
         double val
     for i from 0 <= i < length:
@@ -96,9 +96,9 @@ cdef np.npy_int check_begidx3(np.npy_intp length, double* a1, double* a2, double
             continue
         return i
     else:
-        raise Exception("inputs are all NaN")
+        return length - 1
 
-cdef np.npy_int check_begidx4(np.npy_intp length, double* a1, double* a2, double* a3, double* a4) except -1:
+cdef np.npy_int check_begidx4(np.npy_intp length, double* a1, double* a2, double* a3, double* a4):
     cdef:
         double val
     for i from 0 <= i < length:
@@ -116,13 +116,13 @@ cdef np.npy_int check_begidx4(np.npy_intp length, double* a1, double* a2, double
             continue
         return i
     else:
-        raise Exception("inputs are all NaN")
+        return length - 1
 
 cdef np.ndarray make_double_array(np.npy_intp length, int lookback):
     cdef:
         np.ndarray outreal
         double* outreal_data
-    outreal = PyArray_EMPTY(1, &length, np.NPY_DOUBLE, np.NPY_DEFAULT)
+    outreal = PyArray_EMPTY(1, &length, np.NPY_DOUBLE, np.NPY_ARRAY_DEFAULT)
     outreal_data = <double*>outreal.data
     for i from 0 <= i < min(lookback, length):
         outreal_data[i] = NaN
@@ -132,13 +132,52 @@ cdef np.ndarray make_int_array(np.npy_intp length, int lookback):
     cdef:
         np.ndarray outinteger
         int* outinteger_data
-    outinteger = PyArray_EMPTY(1, &length, np.NPY_INT32, np.NPY_DEFAULT)
+    outinteger = PyArray_EMPTY(1, &length, np.NPY_INT32, np.NPY_ARRAY_DEFAULT)
     outinteger_data = <int*>outinteger.data
     for i from 0 <= i < min(lookback, length):
         outinteger_data[i] = 0
     return outinteger
 
 
+@wraparound(False)  # turn off relative indexing from end of lists
+@boundscheck(False) # turn off bounds-checking for entire function
+def ACCBANDS( np.ndarray high not None , np.ndarray low not None , np.ndarray close not None , int timeperiod=-2**31 ):
+    """ ACCBANDS(high, low, close[, timeperiod=?])
+
+    Acceleration Bands (Overlap Studies)
+
+    Inputs:
+        prices: ['high', 'low', 'close']
+    Parameters:
+        timeperiod: 20
+    Outputs:
+        upperband
+        middleband
+        lowerband
+    """
+    cdef:
+        np.npy_intp length
+        int begidx, endidx, lookback
+        TA_RetCode retCode
+        int outbegidx
+        int outnbelement
+        np.ndarray outrealupperband
+        np.ndarray outrealmiddleband
+        np.ndarray outreallowerband
+    high = check_array(high)
+    low = check_array(low)
+    close = check_array(close)
+    length = check_length3(high, low, close)
+    begidx = check_begidx3(length, <double*>(high.data), <double*>(low.data), <double*>(close.data))
+    endidx = <int>length - begidx - 1
+    lookback = begidx + lib.TA_ACCBANDS_Lookback( timeperiod )
+    outrealupperband = make_double_array(length, lookback)
+    outrealmiddleband = make_double_array(length, lookback)
+    outreallowerband = make_double_array(length, lookback)
+    retCode = lib.TA_ACCBANDS( 0 , endidx , <double *>(high.data)+begidx , <double *>(low.data)+begidx , <double *>(close.data)+begidx , timeperiod , &outbegidx , &outnbelement , <double *>(outrealupperband.data)+lookback , <double *>(outrealmiddleband.data)+lookback , <double *>(outreallowerband.data)+lookback )
+    _ta_check_success("TA_ACCBANDS", retCode)
+    return outrealupperband , outrealmiddleband , outreallowerband 
+
 @wraparound(False)  # turn off relative indexing from end of lists
 @boundscheck(False) # turn off bounds-checking for entire function
 def ACOS( np.ndarray real not None ):
@@ -555,6 +594,37 @@ def AVGPRICE( np.ndarray open not None , np.ndarray high not None , np.ndarray l
     _ta_check_success("TA_AVGPRICE", retCode)
     return outreal 
 
+@wraparound(False)  # turn off relative indexing from end of lists
+@boundscheck(False) # turn off bounds-checking for entire function
+def AVGDEV( np.ndarray real not None , int timeperiod=-2**31 ):
+    """ AVGDEV(real[, timeperiod=?])
+
+    Average Deviation (Price Transform)
+
+    Inputs:
+        real: (any ndarray)
+    Parameters:
+        timeperiod: 14
+    Outputs:
+        real
+    """
+    cdef:
+        np.npy_intp length
+        int begidx, endidx, lookback
+        TA_RetCode retCode
+        int outbegidx
+        int outnbelement
+        np.ndarray outreal
+    real = check_array(real)
+    length = real.shape[0]
+    begidx = check_begidx1(length, <double*>(real.data))
+    endidx = <int>length - begidx - 1
+    lookback = begidx + lib.TA_AVGDEV_Lookback( timeperiod )
+    outreal = make_double_array(length, lookback)
+    retCode = lib.TA_AVGDEV( 0 , endidx , <double *>(real.data)+begidx , timeperiod , &outbegidx , &outnbelement , <double *>(outreal.data)+lookback )
+    _ta_check_success("TA_AVGDEV", retCode)
+    return outreal 
+
 @wraparound(False)  # turn off relative indexing from end of lists
 @boundscheck(False) # turn off bounds-checking for entire function
 def BBANDS( np.ndarray real not None , int timeperiod=-2**31 , double nbdevup=-4e37 , double nbdevdn=-4e37 , int matype=0 ):
@@ -566,8 +636,8 @@ def BBANDS( np.ndarray real not None , int timeperiod=-2**31 , double nbdevup=-4
         real: (any ndarray)
     Parameters:
         timeperiod: 5
-        nbdevup: 2
-        nbdevdn: 2
+        nbdevup: 2.0
+        nbdevdn: 2.0
         matype: 0 (Simple Moving Average)
     Outputs:
         upperband
@@ -3174,6 +3244,38 @@ def HT_TRENDMODE( np.ndarray real not None ):
     _ta_check_success("TA_HT_TRENDMODE", retCode)
     return outinteger 
 
+@wraparound(False)  # turn off relative indexing from end of lists
+@boundscheck(False) # turn off bounds-checking for entire function
+def IMI( np.ndarray open not None , np.ndarray close not None , int timeperiod=-2**31 ):
+    """ IMI(open, close[, timeperiod=?])
+
+    Intraday Momentum Index (Momentum Indicators)
+
+    Inputs:
+        prices: ['open', 'close']
+    Parameters:
+        timeperiod: 14
+    Outputs:
+        real
+    """
+    cdef:
+        np.npy_intp length
+        int begidx, endidx, lookback
+        TA_RetCode retCode
+        int outbegidx
+        int outnbelement
+        np.ndarray outreal
+    open = check_array(open)
+    close = check_array(close)
+    length = check_length2(open, close)
+    begidx = check_begidx2(length, <double*>(open.data), <double*>(close.data))
+    endidx = <int>length - begidx - 1
+    lookback = begidx + lib.TA_IMI_Lookback( timeperiod )
+    outreal = make_double_array(length, lookback)
+    retCode = lib.TA_IMI( 0 , endidx , <double *>(open.data)+begidx , <double *>(close.data)+begidx , timeperiod , &outbegidx , &outnbelement , <double *>(outreal.data)+lookback )
+    _ta_check_success("TA_IMI", retCode)
+    return outreal 
+
 @wraparound(False)  # turn off relative indexing from end of lists
 @boundscheck(False) # turn off bounds-checking for entire function
 def KAMA( np.ndarray real not None , int timeperiod=-2**31 ):
@@ -3667,6 +3769,9 @@ def MAXINDEX( np.ndarray real not None , int timeperiod=-2**31 ):
     outinteger = make_int_array(length, lookback)
     retCode = lib.TA_MAXINDEX( 0 , endidx , <double *>(real.data)+begidx , timeperiod , &outbegidx , &outnbelement , <int *>(outinteger.data)+lookback )
     _ta_check_success("TA_MAXINDEX", retCode)
+    outinteger_data = <int*>outinteger.data
+    for i from lookback <= i < length:
+        outinteger_data[i] += begidx
     return outinteger 
 
 @wraparound(False)  # turn off relative indexing from end of lists
@@ -3856,6 +3961,9 @@ def MININDEX( np.ndarray real not None , int timeperiod=-2**31 ):
     outinteger = make_int_array(length, lookback)
     retCode = lib.TA_MININDEX( 0 , endidx , <double *>(real.data)+begidx , timeperiod , &outbegidx , &outnbelement , <int *>(outinteger.data)+lookback )
     _ta_check_success("TA_MININDEX", retCode)
+    outinteger_data = <int*>outinteger.data
+    for i from lookback <= i < length:
+        outinteger_data[i] += begidx
     return outinteger 
 
 @wraparound(False)  # turn off relative indexing from end of lists
@@ -3924,6 +4032,12 @@ def MINMAXINDEX( np.ndarray real not None , int timeperiod=-2**31 ):
     outmaxidx = make_int_array(length, lookback)
     retCode = lib.TA_MINMAXINDEX( 0 , endidx , <double *>(real.data)+begidx , timeperiod , &outbegidx , &outnbelement , <int *>(outminidx.data)+lookback , <int *>(outmaxidx.data)+lookback )
     _ta_check_success("TA_MINMAXINDEX", retCode)
+    outminidx_data = <int*>outminidx.data
+    for i from lookback <= i < length:
+        outminidx_data[i] += begidx
+    outmaxidx_data = <int*>outmaxidx.data
+    for i from lookback <= i < length:
+        outmaxidx_data[i] += begidx
     return outminidx , outmaxidx 
 
 @wraparound(False)  # turn off relative indexing from end of lists
@@ -4413,8 +4527,8 @@ def SAREXT( np.ndarray high not None , np.ndarray low not None , double startval
     Inputs:
         prices: ['high', 'low']
     Parameters:
-        startvalue: 0
-        offsetonreverse: 0
+        startvalue: 0.0
+        offsetonreverse: 0.0
         accelerationinitlong: 0.02
         accelerationlong: 0.02
         accelerationmaxlong: 0.2
@@ -4571,7 +4685,7 @@ def STDDEV( np.ndarray real not None , int timeperiod=-2**31 , double nbdev=-4e3
         real: (any ndarray)
     Parameters:
         timeperiod: 5
-        nbdev: 1
+        nbdev: 1.0
     Outputs:
         real
     """
@@ -4712,7 +4826,7 @@ def STOCHRSI( np.ndarray real not None , int timeperiod=-2**31 , int fastk_perio
 def SUB( np.ndarray real0 not None , np.ndarray real1 not None ):
     """ SUB(real0, real1)
 
-    Vector Arithmetic Substraction (Math Operators)
+    Vector Arithmetic Subtraction (Math Operators)
 
     Inputs:
         real0: (any ndarray)
@@ -5091,7 +5205,7 @@ def VAR( np.ndarray real not None , int timeperiod=-2**31 , double nbdev=-4e37 )
         real: (any ndarray)
     Parameters:
         timeperiod: 5
-        nbdev: 1
+        nbdev: 1.0
     Outputs:
         real
     """
@@ -5207,4 +5321,4 @@ def WMA( np.ndarray real not None , int timeperiod=-2**31 ):
     _ta_check_success("TA_WMA", retCode)
     return outreal 
 
-__TA_FUNCTION_NAMES__ = ["ACOS","AD","ADD","ADOSC","ADX","ADXR","APO","AROON","AROONOSC","ASIN","ATAN","ATR","AVGPRICE","BBANDS","BETA","BOP","CCI","CDL2CROWS","CDL3BLACKCROWS","CDL3INSIDE","CDL3LINESTRIKE","CDL3OUTSIDE","CDL3STARSINSOUTH","CDL3WHITESOLDIERS","CDLABANDONEDBABY","CDLADVANCEBLOCK","CDLBELTHOLD","CDLBREAKAWAY","CDLCLOSINGMARUBOZU","CDLCONCEALBABYSWALL","CDLCOUNTERATTACK","CDLDARKCLOUDCOVER","CDLDOJI","CDLDOJISTAR","CDLDRAGONFLYDOJI","CDLENGULFING","CDLEVENINGDOJISTAR","CDLEVENINGSTAR","CDLGAPSIDESIDEWHITE","CDLGRAVESTONEDOJI","CDLHAMMER","CDLHANGINGMAN","CDLHARAMI","CDLHARAMICROSS","CDLHIGHWAVE","CDLHIKKAKE","CDLHIKKAKEMOD","CDLHOMINGPIGEON","CDLIDENTICAL3CROWS","CDLINNECK","CDLINVERTEDHAMMER","CDLKICKING","CDLKICKINGBYLENGTH","CDLLADDERBOTTOM","CDLLONGLEGGEDDOJI","CDLLONGLINE","CDLMARUBOZU","CDLMATCHINGLOW","CDLMATHOLD","CDLMORNINGDOJISTAR","CDLMORNINGSTAR","CDLONNECK","CDLPIERCING","CDLRICKSHAWMAN","CDLRISEFALL3METHODS","CDLSEPARATINGLINES","CDLSHOOTINGSTAR","CDLSHORTLINE","CDLSPINNINGTOP","CDLSTALLEDPATTERN","CDLSTICKSANDWICH","CDLTAKURI","CDLTASUKIGAP","CDLTHRUSTING","CDLTRISTAR","CDLUNIQUE3RIVER","CDLUPSIDEGAP2CROWS","CDLXSIDEGAP3METHODS","CEIL","CMO","CORREL","COS","COSH","DEMA","DIV","DX","EMA","EXP","FLOOR","HT_DCPERIOD","HT_DCPHASE","HT_PHASOR","HT_SINE","HT_TRENDLINE","HT_TRENDMODE","KAMA","LINEARREG","LINEARREG_ANGLE","LINEARREG_INTERCEPT","LINEARREG_SLOPE","LN","LOG10","MA","MACD","MACDEXT","MACDFIX","MAMA","MAVP","MAX","MAXINDEX","MEDPRICE","MFI","MIDPOINT","MIDPRICE","MIN","MININDEX","MINMAX","MINMAXINDEX","MINUS_DI","MINUS_DM","MOM","MULT","NATR","OBV","PLUS_DI","PLUS_DM","PPO","ROC","ROCP","ROCR","ROCR100","RSI","SAR","SAREXT","SIN","SINH","SMA","SQRT","STDDEV","STOCH","STOCHF","STOCHRSI","SUB","SUM","T3","TAN","TANH","TEMA","TRANGE","TRIMA","TRIX","TSF","TYPPRICE","ULTOSC","VAR","WCLPRICE","WILLR","WMA"]
+__TA_FUNCTION_NAMES__ = ["ACCBANDS","ACOS","AD","ADD","ADOSC","ADX","ADXR","APO","AROON","AROONOSC","ASIN","ATAN","ATR","AVGPRICE","AVGDEV","BBANDS","BETA","BOP","CCI","CDL2CROWS","CDL3BLACKCROWS","CDL3INSIDE","CDL3LINESTRIKE","CDL3OUTSIDE","CDL3STARSINSOUTH","CDL3WHITESOLDIERS","CDLABANDONEDBABY","CDLADVANCEBLOCK","CDLBELTHOLD","CDLBREAKAWAY","CDLCLOSINGMARUBOZU","CDLCONCEALBABYSWALL","CDLCOUNTERATTACK","CDLDARKCLOUDCOVER","CDLDOJI","CDLDOJISTAR","CDLDRAGONFLYDOJI","CDLENGULFING","CDLEVENINGDOJISTAR","CDLEVENINGSTAR","CDLGAPSIDESIDEWHITE","CDLGRAVESTONEDOJI","CDLHAMMER","CDLHANGINGMAN","CDLHARAMI","CDLHARAMICROSS","CDLHIGHWAVE","CDLHIKKAKE","CDLHIKKAKEMOD","CDLHOMINGPIGEON","CDLIDENTICAL3CROWS","CDLINNECK","CDLINVERTEDHAMMER","CDLKICKING","CDLKICKINGBYLENGTH","CDLLADDERBOTTOM","CDLLONGLEGGEDDOJI","CDLLONGLINE","CDLMARUBOZU","CDLMATCHINGLOW","CDLMATHOLD","CDLMORNINGDOJISTAR","CDLMORNINGSTAR","CDLONNECK","CDLPIERCING","CDLRICKSHAWMAN","CDLRISEFALL3METHODS","CDLSEPARATINGLINES","CDLSHOOTINGSTAR","CDLSHORTLINE","CDLSPINNINGTOP","CDLSTALLEDPATTERN","CDLSTICKSANDWICH","CDLTAKURI","CDLTASUKIGAP","CDLTHRUSTING","CDLTRISTAR","CDLUNIQUE3RIVER","CDLUPSIDEGAP2CROWS","CDLXSIDEGAP3METHODS","CEIL","CMO","CORREL","COS","COSH","DEMA","DIV","DX","EMA","EXP","FLOOR","HT_DCPERIOD","HT_DCPHASE","HT_PHASOR","HT_SINE","HT_TRENDLINE","HT_TRENDMODE","IMI","KAMA","LINEARREG","LINEARREG_ANGLE","LINEARREG_INTERCEPT","LINEARREG_SLOPE","LN","LOG10","MA","MACD","MACDEXT","MACDFIX","MAMA","MAVP","MAX","MAXINDEX","MEDPRICE","MFI","MIDPOINT","MIDPRICE","MIN","MININDEX","MINMAX","MINMAXINDEX","MINUS_DI","MINUS_DM","MOM","MULT","NATR","OBV","PLUS_DI","PLUS_DM","PPO","ROC","ROCP","ROCR","ROCR100","RSI","SAR","SAREXT","SIN","SINH","SMA","SQRT","STDDEV","STOCH","STOCHF","STOCHRSI","SUB","SUM","T3","TAN","TANH","TEMA","TRANGE","TRIMA","TRIX","TSF","TYPPRICE","ULTOSC","VAR","WCLPRICE","WILLR","WMA"]
diff --git a/talib/_stream.pxi b/talib/_stream.pxi
index fc235442b..b1575b2cc 100644
--- a/talib/_stream.pxi
+++ b/talib/_stream.pxi
@@ -3,8 +3,49 @@ from cython import boundscheck, wraparound
 cimport _ta_lib as lib
 from _ta_lib cimport TA_RetCode
 # NOTE: _ta_check_success, NaN are defined in common.pxi
-#       NumPy C API is initialize in _func.pxi
 
+np.import_array() # Initialize the NumPy C API
+
+@wraparound(False)  # turn off relative indexing from end of lists
+@boundscheck(False) # turn off bounds-checking for entire function
+def stream_ACCBANDS( np.ndarray high not None , np.ndarray low not None , np.ndarray close not None , int timeperiod=-2**31 ):
+    """ ACCBANDS(high, low, close[, timeperiod=?])
+
+    Acceleration Bands (Overlap Studies)
+
+    Inputs:
+        prices: ['high', 'low', 'close']
+    Parameters:
+        timeperiod: 20
+    Outputs:
+        upperband
+        middleband
+        lowerband
+    """
+    cdef:
+        np.npy_intp length
+        TA_RetCode retCode
+        double* high_data
+        double* low_data
+        double* close_data
+        int outbegidx
+        int outnbelement
+        double outrealupperband
+        double outrealmiddleband
+        double outreallowerband
+    high = check_array(high)
+    high_data = <double*>high.data
+    low = check_array(low)
+    low_data = <double*>low.data
+    close = check_array(close)
+    close_data = <double*>close.data
+    length = check_length3(high, low, close)
+    outrealupperband = NaN
+    outrealmiddleband = NaN
+    outreallowerband = NaN
+    retCode = lib.TA_ACCBANDS( <int>(length) - 1 , <int>(length) - 1 , high_data , low_data , close_data , timeperiod , &outbegidx , &outnbelement , &outrealupperband , &outrealmiddleband , &outreallowerband )
+    _ta_check_success("TA_ACCBANDS", retCode)
+    return outrealupperband , outrealmiddleband , outreallowerband 
 
 @wraparound(False)  # turn off relative indexing from end of lists
 @boundscheck(False) # turn off bounds-checking for entire function
@@ -432,6 +473,35 @@ def stream_AVGPRICE( np.ndarray open not None , np.ndarray high not None , np.nd
     _ta_check_success("TA_AVGPRICE", retCode)
     return outreal 
 
+@wraparound(False)  # turn off relative indexing from end of lists
+@boundscheck(False) # turn off bounds-checking for entire function
+def stream_AVGDEV( np.ndarray real not None , int timeperiod=-2**31 ):
+    """ AVGDEV(real[, timeperiod=?])
+
+    Average Deviation (Price Transform)
+
+    Inputs:
+        real: (any ndarray)
+    Parameters:
+        timeperiod: 14
+    Outputs:
+        real
+    """
+    cdef:
+        np.npy_intp length
+        TA_RetCode retCode
+        double* real_data
+        int outbegidx
+        int outnbelement
+        double outreal
+    real = check_array(real)
+    real_data = <double*>real.data
+    length = real.shape[0]
+    outreal = NaN
+    retCode = lib.TA_AVGDEV( <int>(length) - 1 , <int>(length) - 1 , real_data , timeperiod , &outbegidx , &outnbelement , &outreal )
+    _ta_check_success("TA_AVGDEV", retCode)
+    return outreal 
+
 @wraparound(False)  # turn off relative indexing from end of lists
 @boundscheck(False) # turn off bounds-checking for entire function
 def stream_BBANDS( np.ndarray real not None , int timeperiod=-2**31 , double nbdevup=-4e37 , double nbdevdn=-4e37 , int matype=0 ):
@@ -443,8 +513,8 @@ def stream_BBANDS( np.ndarray real not None , int timeperiod=-2**31 , double nbd
         real: (any ndarray)
     Parameters:
         timeperiod: 5
-        nbdevup: 2
-        nbdevdn: 2
+        nbdevup: 2.0
+        nbdevdn: 2.0
         matype: 0 (Simple Moving Average)
     Outputs:
         upperband
@@ -3273,6 +3343,38 @@ def stream_HT_TRENDMODE( np.ndarray real not None ):
     _ta_check_success("TA_HT_TRENDMODE", retCode)
     return outinteger 
 
+@wraparound(False)  # turn off relative indexing from end of lists
+@boundscheck(False) # turn off bounds-checking for entire function
+def stream_IMI( np.ndarray open not None , np.ndarray close not None , int timeperiod=-2**31 ):
+    """ IMI(open, close[, timeperiod=?])
+
+    Intraday Momentum Index (Momentum Indicators)
+
+    Inputs:
+        prices: ['open', 'close']
+    Parameters:
+        timeperiod: 14
+    Outputs:
+        real
+    """
+    cdef:
+        np.npy_intp length
+        TA_RetCode retCode
+        double* open_data
+        double* close_data
+        int outbegidx
+        int outnbelement
+        double outreal
+    open = check_array(open)
+    open_data = <double*>open.data
+    close = check_array(close)
+    close_data = <double*>close.data
+    length = check_length2(open, close)
+    outreal = NaN
+    retCode = lib.TA_IMI( <int>(length) - 1 , <int>(length) - 1 , open_data , close_data , timeperiod , &outbegidx , &outnbelement , &outreal )
+    _ta_check_success("TA_IMI", retCode)
+    return outreal 
+
 @wraparound(False)  # turn off relative indexing from end of lists
 @boundscheck(False) # turn off bounds-checking for entire function
 def stream_KAMA( np.ndarray real not None , int timeperiod=-2**31 ):
@@ -4470,8 +4572,8 @@ def stream_SAREXT( np.ndarray high not None , np.ndarray low not None , double s
     Inputs:
         prices: ['high', 'low']
     Parameters:
-        startvalue: 0
-        offsetonreverse: 0
+        startvalue: 0.0
+        offsetonreverse: 0.0
         accelerationinitlong: 0.02
         accelerationlong: 0.02
         accelerationmaxlong: 0.2
@@ -4620,7 +4722,7 @@ def stream_STDDEV( np.ndarray real not None , int timeperiod=-2**31 , double nbd
         real: (any ndarray)
     Parameters:
         timeperiod: 5
-        nbdev: 1
+        nbdev: 1.0
     Outputs:
         real
     """
@@ -4761,7 +4863,7 @@ def stream_STOCHRSI( np.ndarray real not None , int timeperiod=-2**31 , int fast
 def stream_SUB( np.ndarray real0 not None , np.ndarray real1 not None ):
     """ SUB(real0, real1)
 
-    Vector Arithmetic Substraction (Math Operators)
+    Vector Arithmetic Subtraction (Math Operators)
 
     Inputs:
         real0: (any ndarray)
@@ -5130,7 +5232,7 @@ def stream_VAR( np.ndarray real not None , int timeperiod=-2**31 , double nbdev=
         real: (any ndarray)
     Parameters:
         timeperiod: 5
-        nbdev: 1
+        nbdev: 1.0
     Outputs:
         real
     """
diff --git a/talib/_ta_lib.c b/talib/_ta_lib.c
index 8fe237d90..2b6418094 100644
--- a/talib/_ta_lib.c
+++ b/talib/_ta_lib.c
@@ -1,20 +1,36 @@
-/* Generated by Cython 0.29.2 */
+/* Generated by Cython 3.1.5 */
 
+#ifndef PY_SSIZE_T_CLEAN
 #define PY_SSIZE_T_CLEAN
+#endif /* PY_SSIZE_T_CLEAN */
+/* InitLimitedAPI */
+#if defined(Py_LIMITED_API)
+  #if !defined(CYTHON_LIMITED_API)
+  #define CYTHON_LIMITED_API 1
+  #endif
+#elif defined(CYTHON_LIMITED_API)
+  #ifdef _MSC_VER
+  #pragma message ("Limited API usage is enabled with 'CYTHON_LIMITED_API' but 'Py_LIMITED_API' does not define a Python target version. Consider setting 'Py_LIMITED_API' instead.")
+  #else
+  #warning Limited API usage is enabled with 'CYTHON_LIMITED_API' but 'Py_LIMITED_API' does not define a Python target version. Consider setting 'Py_LIMITED_API' instead.
+  #endif
+#endif
+
 #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 < 0x03030000)
-    #error Cython requires Python 2.6+ or Python 3.3+.
+#elif PY_VERSION_HEX < 0x03080000
+    #error Cython requires Python 3.8+.
 #else
-#define CYTHON_ABI "0_29_2"
-#define CYTHON_HEX_VERSION 0x001D02F0
+#define __PYX_ABI_VERSION "3_1_5"
+#define CYTHON_HEX_VERSION 0x030105F0
 #define CYTHON_FUTURE_DIVISION 0
+/* CModulePreamble */
 #include <stddef.h>
 #ifndef offsetof
   #define offsetof(type, member) ( (size_t) & ((type*)0) -> member )
 #endif
-#if !defined(WIN32) && !defined(MS_WINDOWS)
+#if !defined(_WIN32) && !defined(WIN32) && !defined(MS_WINDOWS)
   #ifndef __stdcall
     #define __stdcall
   #endif
@@ -33,9 +49,7 @@
 #endif
 #define __PYX_COMMA ,
 #ifndef HAVE_LONG_LONG
-  #if PY_VERSION_HEX >= 0x02070000
-    #define HAVE_LONG_LONG
-  #endif
+  #define HAVE_LONG_LONG
 #endif
 #ifndef PY_LONG_LONG
   #define PY_LONG_LONG LONG_LONG
@@ -43,20 +57,21 @@
 #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 __PYX_LIMITED_VERSION_HEX PY_VERSION_HEX
+#if defined(GRAALVM_PYTHON)
+  /* For very preliminary testing purposes. Most variables are set the same as PyPy.
+     The existence of this section does not imply that anything works or is even tested */
+  #define CYTHON_COMPILING_IN_PYPY 0
   #define CYTHON_COMPILING_IN_CPYTHON 0
+  #define CYTHON_COMPILING_IN_LIMITED_API 0
+  #define CYTHON_COMPILING_IN_GRAAL 1
+  #define CYTHON_COMPILING_IN_CPYTHON_FREETHREADING 0
   #undef CYTHON_USE_TYPE_SLOTS
   #define CYTHON_USE_TYPE_SLOTS 0
+  #undef CYTHON_USE_TYPE_SPECS
+  #define CYTHON_USE_TYPE_SPECS 0
   #undef CYTHON_USE_PYTYPE_LOOKUP
   #define CYTHON_USE_PYTYPE_LOOKUP 0
-  #if PY_VERSION_HEX < 0x03050000
-    #undef CYTHON_USE_ASYNC_SLOTS
-    #define CYTHON_USE_ASYNC_SLOTS 0
-  #elif !defined(CYTHON_USE_ASYNC_SLOTS)
-    #define CYTHON_USE_ASYNC_SLOTS 1
-  #endif
   #undef CYTHON_USE_PYLIST_INTERNALS
   #define CYTHON_USE_PYLIST_INTERNALS 0
   #undef CYTHON_USE_UNICODE_INTERNALS
@@ -67,95 +82,219 @@
   #define CYTHON_USE_PYLONG_INTERNALS 0
   #undef CYTHON_AVOID_BORROWED_REFS
   #define CYTHON_AVOID_BORROWED_REFS 1
+  #undef CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS
+  #define CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS 1
   #undef CYTHON_ASSUME_SAFE_MACROS
   #define CYTHON_ASSUME_SAFE_MACROS 0
+  #undef CYTHON_ASSUME_SAFE_SIZE
+  #define CYTHON_ASSUME_SAFE_SIZE 0
   #undef CYTHON_UNPACK_METHODS
   #define CYTHON_UNPACK_METHODS 0
   #undef CYTHON_FAST_THREAD_STATE
   #define CYTHON_FAST_THREAD_STATE 0
+  #undef CYTHON_FAST_GIL
+  #define CYTHON_FAST_GIL 0
+  #undef CYTHON_METH_FASTCALL
+  #define CYTHON_METH_FASTCALL 0
   #undef CYTHON_FAST_PYCALL
   #define CYTHON_FAST_PYCALL 0
+  #ifndef CYTHON_PEP487_INIT_SUBCLASS
+    #define CYTHON_PEP487_INIT_SUBCLASS 1
+  #endif
   #undef CYTHON_PEP489_MULTI_PHASE_INIT
-  #define CYTHON_PEP489_MULTI_PHASE_INIT 0
+  #define CYTHON_PEP489_MULTI_PHASE_INIT 1
+  #undef CYTHON_USE_MODULE_STATE
+  #define CYTHON_USE_MODULE_STATE 0
+  #undef CYTHON_USE_SYS_MONITORING
+  #define CYTHON_USE_SYS_MONITORING 0
   #undef CYTHON_USE_TP_FINALIZE
   #define CYTHON_USE_TP_FINALIZE 0
+  #undef CYTHON_USE_AM_SEND
+  #define CYTHON_USE_AM_SEND 0
   #undef CYTHON_USE_DICT_VERSIONS
   #define CYTHON_USE_DICT_VERSIONS 0
   #undef CYTHON_USE_EXC_INFO_STACK
-  #define CYTHON_USE_EXC_INFO_STACK 0
-#elif defined(PYSTON_VERSION)
-  #define CYTHON_COMPILING_IN_PYPY 0
-  #define CYTHON_COMPILING_IN_PYSTON 1
+  #define CYTHON_USE_EXC_INFO_STACK 1
+  #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC
+    #define CYTHON_UPDATE_DESCRIPTOR_DOC 0
+  #endif
+  #undef CYTHON_USE_FREELISTS
+  #define CYTHON_USE_FREELISTS 0
+#elif defined(PYPY_VERSION)
+  #define CYTHON_COMPILING_IN_PYPY 1
   #define CYTHON_COMPILING_IN_CPYTHON 0
-  #ifndef CYTHON_USE_TYPE_SLOTS
-    #define CYTHON_USE_TYPE_SLOTS 1
+  #define CYTHON_COMPILING_IN_LIMITED_API 0
+  #define CYTHON_COMPILING_IN_GRAAL 0
+  #define CYTHON_COMPILING_IN_CPYTHON_FREETHREADING 0
+  #undef CYTHON_USE_TYPE_SLOTS
+  #define CYTHON_USE_TYPE_SLOTS 1
+  #ifndef CYTHON_USE_TYPE_SPECS
+    #define CYTHON_USE_TYPE_SPECS 0
   #endif
   #undef CYTHON_USE_PYTYPE_LOOKUP
   #define CYTHON_USE_PYTYPE_LOOKUP 0
-  #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_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_AVOID_THREAD_UNSAFE_BORROWED_REFS
+  #define CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS 1
+  #undef CYTHON_ASSUME_SAFE_MACROS
+  #define CYTHON_ASSUME_SAFE_MACROS 0
+  #ifndef CYTHON_ASSUME_SAFE_SIZE
+    #define CYTHON_ASSUME_SAFE_SIZE 1
+  #endif
+  #undef CYTHON_UNPACK_METHODS
+  #define CYTHON_UNPACK_METHODS 0
+  #undef CYTHON_FAST_THREAD_STATE
+  #define CYTHON_FAST_THREAD_STATE 0
+  #undef CYTHON_FAST_GIL
+  #define CYTHON_FAST_GIL 0
+  #undef CYTHON_METH_FASTCALL
+  #define CYTHON_METH_FASTCALL 0
+  #undef CYTHON_FAST_PYCALL
+  #define CYTHON_FAST_PYCALL 0
+  #ifndef CYTHON_PEP487_INIT_SUBCLASS
+    #define CYTHON_PEP487_INIT_SUBCLASS 1
+  #endif
+  #if PY_VERSION_HEX < 0x03090000
+    #undef CYTHON_PEP489_MULTI_PHASE_INIT
+    #define CYTHON_PEP489_MULTI_PHASE_INIT 0
+  #elif !defined(CYTHON_PEP489_MULTI_PHASE_INIT)
+    #define CYTHON_PEP489_MULTI_PHASE_INIT 1
+  #endif
+  #undef CYTHON_USE_MODULE_STATE
+  #define CYTHON_USE_MODULE_STATE 0
+  #undef CYTHON_USE_SYS_MONITORING
+  #define CYTHON_USE_SYS_MONITORING 0
+  #ifndef CYTHON_USE_TP_FINALIZE
+    #define CYTHON_USE_TP_FINALIZE (PYPY_VERSION_NUM >= 0x07030C00)
+  #endif
+  #undef CYTHON_USE_AM_SEND
+  #define CYTHON_USE_AM_SEND 0
+  #undef CYTHON_USE_DICT_VERSIONS
+  #define CYTHON_USE_DICT_VERSIONS 0
+  #undef CYTHON_USE_EXC_INFO_STACK
+  #define CYTHON_USE_EXC_INFO_STACK 0
+  #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC
+    #define CYTHON_UPDATE_DESCRIPTOR_DOC (PYPY_VERSION_NUM >= 0x07031100)
+  #endif
+  #undef CYTHON_USE_FREELISTS
+  #define CYTHON_USE_FREELISTS 0
+#elif defined(CYTHON_LIMITED_API)
+  #ifdef Py_LIMITED_API
+    #undef __PYX_LIMITED_VERSION_HEX
+    #define __PYX_LIMITED_VERSION_HEX Py_LIMITED_API
+  #endif
+  #define CYTHON_COMPILING_IN_PYPY 0
+  #define CYTHON_COMPILING_IN_CPYTHON 0
+  #define CYTHON_COMPILING_IN_LIMITED_API 1
+  #define CYTHON_COMPILING_IN_GRAAL 0
+  #define CYTHON_COMPILING_IN_CPYTHON_FREETHREADING 0
+  #undef CYTHON_CLINE_IN_TRACEBACK
+  #define CYTHON_CLINE_IN_TRACEBACK 0
+  #undef CYTHON_USE_TYPE_SLOTS
+  #define CYTHON_USE_TYPE_SLOTS 0
+  #undef CYTHON_USE_TYPE_SPECS
+  #define CYTHON_USE_TYPE_SPECS 1
+  #undef CYTHON_USE_PYTYPE_LOOKUP
+  #define CYTHON_USE_PYTYPE_LOOKUP 0
+  #undef CYTHON_USE_PYLIST_INTERNALS
+  #define CYTHON_USE_PYLIST_INTERNALS 0
+  #undef CYTHON_USE_UNICODE_INTERNALS
+  #define CYTHON_USE_UNICODE_INTERNALS 0
+  #ifndef CYTHON_USE_UNICODE_WRITER
+    #define CYTHON_USE_UNICODE_WRITER 0
+  #endif
+  #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
+  #ifndef CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS
+    #define CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS 0
   #endif
+  #undef CYTHON_ASSUME_SAFE_MACROS
+  #define CYTHON_ASSUME_SAFE_MACROS 0
+  #undef CYTHON_ASSUME_SAFE_SIZE
+  #define CYTHON_ASSUME_SAFE_SIZE 0
+  #undef CYTHON_UNPACK_METHODS
+  #define CYTHON_UNPACK_METHODS 0
   #undef CYTHON_FAST_THREAD_STATE
   #define CYTHON_FAST_THREAD_STATE 0
+  #undef CYTHON_FAST_GIL
+  #define CYTHON_FAST_GIL 0
+  #undef CYTHON_METH_FASTCALL
+  #define CYTHON_METH_FASTCALL (__PYX_LIMITED_VERSION_HEX >= 0x030C0000)
   #undef CYTHON_FAST_PYCALL
   #define CYTHON_FAST_PYCALL 0
-  #undef CYTHON_PEP489_MULTI_PHASE_INIT
-  #define CYTHON_PEP489_MULTI_PHASE_INIT 0
-  #undef CYTHON_USE_TP_FINALIZE
-  #define CYTHON_USE_TP_FINALIZE 0
+  #ifndef CYTHON_PEP487_INIT_SUBCLASS
+    #define CYTHON_PEP487_INIT_SUBCLASS 1
+  #endif
+  #ifndef CYTHON_PEP489_MULTI_PHASE_INIT
+    #define CYTHON_PEP489_MULTI_PHASE_INIT 1
+  #endif
+  #ifndef CYTHON_USE_MODULE_STATE
+    #define CYTHON_USE_MODULE_STATE 0
+  #endif
+  #undef CYTHON_USE_SYS_MONITORING
+  #define CYTHON_USE_SYS_MONITORING 0
+  #ifndef CYTHON_USE_TP_FINALIZE
+    #define CYTHON_USE_TP_FINALIZE 0
+  #endif
+  #ifndef CYTHON_USE_AM_SEND
+    #define CYTHON_USE_AM_SEND (__PYX_LIMITED_VERSION_HEX >= 0x030A0000)
+  #endif
   #undef CYTHON_USE_DICT_VERSIONS
   #define CYTHON_USE_DICT_VERSIONS 0
   #undef CYTHON_USE_EXC_INFO_STACK
   #define CYTHON_USE_EXC_INFO_STACK 0
+  #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC
+    #define CYTHON_UPDATE_DESCRIPTOR_DOC 0
+  #endif
+  #undef CYTHON_USE_FREELISTS
+  #define CYTHON_USE_FREELISTS 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_COMPILING_IN_LIMITED_API 0
+  #define CYTHON_COMPILING_IN_GRAAL 0
+  #ifdef Py_GIL_DISABLED
+    #define CYTHON_COMPILING_IN_CPYTHON_FREETHREADING 1
+  #else
+    #define CYTHON_COMPILING_IN_CPYTHON_FREETHREADING 0
+  #endif
+  #if PY_VERSION_HEX < 0x030A0000
+    #undef CYTHON_USE_TYPE_SLOTS
+    #define CYTHON_USE_TYPE_SLOTS 1
+  #elif !defined(CYTHON_USE_TYPE_SLOTS)
     #define CYTHON_USE_TYPE_SLOTS 1
   #endif
-  #if PY_VERSION_HEX < 0x02070000
-    #undef CYTHON_USE_PYTYPE_LOOKUP
-    #define CYTHON_USE_PYTYPE_LOOKUP 0
-  #elif !defined(CYTHON_USE_PYTYPE_LOOKUP)
-    #define CYTHON_USE_PYTYPE_LOOKUP 1
+  #ifndef CYTHON_USE_TYPE_SPECS
+    #define CYTHON_USE_TYPE_SPECS 0
   #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
+  #ifndef CYTHON_USE_PYTYPE_LOOKUP
+    #define CYTHON_USE_PYTYPE_LOOKUP 1
   #endif
-  #if PY_VERSION_HEX < 0x02070000
-    #undef CYTHON_USE_PYLONG_INTERNALS
-    #define CYTHON_USE_PYLONG_INTERNALS 0
-  #elif !defined(CYTHON_USE_PYLONG_INTERNALS)
+  #ifndef CYTHON_USE_PYLONG_INTERNALS
     #define CYTHON_USE_PYLONG_INTERNALS 1
   #endif
-  #ifndef CYTHON_USE_PYLIST_INTERNALS
+  #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING
+    #undef CYTHON_USE_PYLIST_INTERNALS
+    #define CYTHON_USE_PYLIST_INTERNALS 0
+  #elif !defined(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
+  #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING || PY_VERSION_HEX >= 0x030B00A2
     #undef CYTHON_USE_UNICODE_WRITER
     #define CYTHON_USE_UNICODE_WRITER 0
   #elif !defined(CYTHON_USE_UNICODE_WRITER)
@@ -164,36 +303,82 @@
   #ifndef CYTHON_AVOID_BORROWED_REFS
     #define CYTHON_AVOID_BORROWED_REFS 0
   #endif
+  #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING
+    #undef CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS
+    #define CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS 1
+  #elif !defined(CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS)
+    #define CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS 0
+  #endif
   #ifndef CYTHON_ASSUME_SAFE_MACROS
     #define CYTHON_ASSUME_SAFE_MACROS 1
   #endif
+  #ifndef CYTHON_ASSUME_SAFE_SIZE
+    #define CYTHON_ASSUME_SAFE_SIZE 1
+  #endif
   #ifndef CYTHON_UNPACK_METHODS
     #define CYTHON_UNPACK_METHODS 1
   #endif
   #ifndef CYTHON_FAST_THREAD_STATE
     #define CYTHON_FAST_THREAD_STATE 1
   #endif
+  #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING
+    #undef CYTHON_FAST_GIL
+    #define CYTHON_FAST_GIL 0
+  #elif !defined(CYTHON_FAST_GIL)
+    #define CYTHON_FAST_GIL (PY_VERSION_HEX < 0x030C00A6)
+  #endif
+  #ifndef CYTHON_METH_FASTCALL
+    #define CYTHON_METH_FASTCALL 1
+  #endif
   #ifndef CYTHON_FAST_PYCALL
     #define CYTHON_FAST_PYCALL 1
   #endif
+  #ifndef CYTHON_PEP487_INIT_SUBCLASS
+    #define CYTHON_PEP487_INIT_SUBCLASS 1
+  #endif
   #ifndef CYTHON_PEP489_MULTI_PHASE_INIT
-    #define CYTHON_PEP489_MULTI_PHASE_INIT (PY_VERSION_HEX >= 0x03050000)
+    #define CYTHON_PEP489_MULTI_PHASE_INIT 1
+  #endif
+  #ifndef CYTHON_USE_MODULE_STATE
+    #define CYTHON_USE_MODULE_STATE 0
+  #endif
+  #ifndef CYTHON_USE_SYS_MONITORING
+    #define CYTHON_USE_SYS_MONITORING (PY_VERSION_HEX >= 0x030d00B1)
   #endif
   #ifndef CYTHON_USE_TP_FINALIZE
-    #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1)
+    #define CYTHON_USE_TP_FINALIZE 1
   #endif
-  #ifndef CYTHON_USE_DICT_VERSIONS
-    #define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX >= 0x030600B1)
+  #ifndef CYTHON_USE_AM_SEND
+    #define CYTHON_USE_AM_SEND 1
+  #endif
+  #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING
+    #undef CYTHON_USE_DICT_VERSIONS
+    #define CYTHON_USE_DICT_VERSIONS 0
+  #elif !defined(CYTHON_USE_DICT_VERSIONS)
+    #define CYTHON_USE_DICT_VERSIONS  (PY_VERSION_HEX < 0x030C00A5 && !CYTHON_USE_MODULE_STATE)
   #endif
   #ifndef CYTHON_USE_EXC_INFO_STACK
-    #define CYTHON_USE_EXC_INFO_STACK (PY_VERSION_HEX >= 0x030700A3)
+    #define CYTHON_USE_EXC_INFO_STACK 1
+  #endif
+  #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC
+    #define CYTHON_UPDATE_DESCRIPTOR_DOC 1
   #endif
+  #ifndef CYTHON_USE_FREELISTS
+    #define CYTHON_USE_FREELISTS (!CYTHON_COMPILING_IN_CPYTHON_FREETHREADING)
+  #endif
+#endif
+#ifndef CYTHON_FAST_PYCCALL
+#define CYTHON_FAST_PYCCALL  CYTHON_FAST_PYCALL
+#endif
+#ifndef CYTHON_VECTORCALL
+#if CYTHON_COMPILING_IN_LIMITED_API
+#define CYTHON_VECTORCALL  (__PYX_LIMITED_VERSION_HEX >= 0x030C0000)
+#else
+#define CYTHON_VECTORCALL  (CYTHON_FAST_PYCCALL && PY_VERSION_HEX >= 0x030800B1)
 #endif
-#if !defined(CYTHON_FAST_PYCCALL)
-#define CYTHON_FAST_PYCCALL  (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1)
 #endif
+#define CYTHON_BACKPORT_VECTORCALL (CYTHON_METH_FASTCALL && PY_VERSION_HEX < 0x030800B1)
 #if CYTHON_USE_PYLONG_INTERNALS
-  #include "longintrepr.h"
   #undef SHIFT
   #undef BASE
   #undef MASK
@@ -201,6 +386,9 @@
     enum { __pyx_check_sizeof_voidp = 1 / (int)(SIZEOF_VOID_P == sizeof(void*)) };
   #endif
 #endif
+#ifndef CYTHON_LOCK_AND_GIL_DEADLOCK_AVOIDANCE_TIME
+  #define CYTHON_LOCK_AND_GIL_DEADLOCK_AVOIDANCE_TIME 100
+#endif
 #ifndef __has_attribute
   #define __has_attribute(x) 0
 #endif
@@ -218,6 +406,17 @@
     #define CYTHON_RESTRICT
   #endif
 #endif
+#ifndef CYTHON_UNUSED
+  #if defined(__cplusplus)
+    /* for clang __has_cpp_attribute(maybe_unused) is true even before C++17
+     * but leads to warnings with -pedantic, since it is a C++17 feature */
+    #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L)
+      #if __has_cpp_attribute(maybe_unused)
+        #define CYTHON_UNUSED [[maybe_unused]]
+      #endif
+    #endif
+  #endif
+#endif
 #ifndef CYTHON_UNUSED
 # if defined(__GNUC__)
 #   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
@@ -231,42 +430,76 @@
 #   define CYTHON_UNUSED
 # endif
 #endif
-#ifndef CYTHON_MAYBE_UNUSED_VAR
+#ifndef CYTHON_UNUSED_VAR
 #  if defined(__cplusplus)
-     template<class T> void CYTHON_MAYBE_UNUSED_VAR( const T& ) { }
+     template<class T> void CYTHON_UNUSED_VAR( const T& ) { }
 #  else
-#    define CYTHON_MAYBE_UNUSED_VAR(x) (void)(x)
+#    define CYTHON_UNUSED_VAR(x) (void)(x)
 #  endif
 #endif
+#ifndef CYTHON_MAYBE_UNUSED_VAR
+  #define CYTHON_MAYBE_UNUSED_VAR(x) CYTHON_UNUSED_VAR(x)
+#endif
 #ifndef CYTHON_NCP_UNUSED
-# if CYTHON_COMPILING_IN_CPYTHON
+# if CYTHON_COMPILING_IN_CPYTHON && !CYTHON_COMPILING_IN_CPYTHON_FREETHREADING
 #  define CYTHON_NCP_UNUSED
 # else
 #  define CYTHON_NCP_UNUSED CYTHON_UNUSED
 # endif
 #endif
+#ifndef CYTHON_USE_CPP_STD_MOVE
+  #if defined(__cplusplus) && (\
+    __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1600))
+    #define CYTHON_USE_CPP_STD_MOVE 1
+  #else
+    #define CYTHON_USE_CPP_STD_MOVE 0
+  #endif
+#endif
 #define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None)
 #ifdef _MSC_VER
     #ifndef _MSC_STDINT_H_
         #if _MSC_VER < 1300
-           typedef unsigned char     uint8_t;
-           typedef unsigned int      uint32_t;
+            typedef unsigned char     uint8_t;
+            typedef unsigned short    uint16_t;
+            typedef unsigned int      uint32_t;
+        #else
+            typedef unsigned __int8   uint8_t;
+            typedef unsigned __int16  uint16_t;
+            typedef unsigned __int32  uint32_t;
+        #endif
+    #endif
+    #if _MSC_VER < 1300
+        #ifdef _WIN64
+            typedef unsigned long long  __pyx_uintptr_t;
+        #else
+            typedef unsigned int        __pyx_uintptr_t;
+        #endif
+    #else
+        #ifdef _WIN64
+            typedef unsigned __int64    __pyx_uintptr_t;
         #else
-           typedef unsigned __int8   uint8_t;
-           typedef unsigned __int32  uint32_t;
+            typedef unsigned __int32    __pyx_uintptr_t;
         #endif
     #endif
 #else
-   #include <stdint.h>
+    #include <stdint.h>
+    typedef uintptr_t  __pyx_uintptr_t;
 #endif
 #ifndef CYTHON_FALLTHROUGH
-  #if defined(__cplusplus) && __cplusplus >= 201103L
-    #if __has_cpp_attribute(fallthrough)
-      #define CYTHON_FALLTHROUGH [[fallthrough]]
-    #elif __has_cpp_attribute(clang::fallthrough)
-      #define CYTHON_FALLTHROUGH [[clang::fallthrough]]
-    #elif __has_cpp_attribute(gnu::fallthrough)
-      #define CYTHON_FALLTHROUGH [[gnu::fallthrough]]
+  #if defined(__cplusplus)
+    /* for clang __has_cpp_attribute(fallthrough) is true even before C++17
+     * but leads to warnings with -pedantic, since it is a C++17 feature */
+    #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L)
+      #if __has_cpp_attribute(fallthrough)
+        #define CYTHON_FALLTHROUGH [[fallthrough]]
+      #endif
+    #endif
+    #ifndef CYTHON_FALLTHROUGH
+      #if __has_cpp_attribute(clang::fallthrough)
+        #define CYTHON_FALLTHROUGH [[clang::fallthrough]]
+      #elif __has_cpp_attribute(gnu::fallthrough)
+        #define CYTHON_FALLTHROUGH [[gnu::fallthrough]]
+      #endif
     #endif
   #endif
   #ifndef CYTHON_FALLTHROUGH
@@ -276,14 +509,31 @@
       #define CYTHON_FALLTHROUGH
     #endif
   #endif
-  #if defined(__clang__ ) && defined(__apple_build_version__)
+  #if defined(__clang__) && defined(__apple_build_version__)
     #if __apple_build_version__ < 7000000
       #undef  CYTHON_FALLTHROUGH
       #define CYTHON_FALLTHROUGH
     #endif
   #endif
 #endif
+#ifndef Py_UNREACHABLE
+  #define Py_UNREACHABLE()  assert(0); abort()
+#endif
+#ifdef __cplusplus
+  template <typename T>
+  struct __PYX_IS_UNSIGNED_IMPL {static const bool value = T(0) < T(-1);};
+  #define __PYX_IS_UNSIGNED(type) (__PYX_IS_UNSIGNED_IMPL<type>::value)
+#else
+  #define __PYX_IS_UNSIGNED(type) (((type)-1) > 0)
+#endif
+#if CYTHON_COMPILING_IN_PYPY == 1
+  #define __PYX_NEED_TP_PRINT_SLOT  (PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x030A0000)
+#else
+  #define __PYX_NEED_TP_PRINT_SLOT  (PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000)
+#endif
+#define __PYX_REINTERPRET_FUNCION(func_pointer, other_pointer) ((func_pointer)(void(*)(void))(other_pointer))
 
+/* CInitCode */
 #ifndef CYTHON_INLINE
   #if defined(__clang__)
     #define CYTHON_INLINE __inline__ __attribute__ ((__unused__))
@@ -298,21 +548,72 @@
   #endif
 #endif
 
-#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag)
-  #define Py_OptimizeFlag 0
-#endif
+/* PythonCompatibility */
 #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
+#define __Pyx_BUILTIN_MODULE_NAME "builtins"
+#define __Pyx_DefaultClassType PyType_Type
+#if CYTHON_COMPILING_IN_LIMITED_API
+    #ifndef CO_OPTIMIZED
+    static int CO_OPTIMIZED;
+    #endif
+    #ifndef CO_NEWLOCALS
+    static int CO_NEWLOCALS;
+    #endif
+    #ifndef CO_VARARGS
+    static int CO_VARARGS;
+    #endif
+    #ifndef CO_VARKEYWORDS
+    static int CO_VARKEYWORDS;
+    #endif
+    #ifndef CO_ASYNC_GENERATOR
+    static int CO_ASYNC_GENERATOR;
+    #endif
+    #ifndef CO_GENERATOR
+    static int CO_GENERATOR;
+    #endif
+    #ifndef CO_COROUTINE
+    static int CO_COROUTINE;
+    #endif
+#else
+    #ifndef CO_COROUTINE
+      #define CO_COROUTINE 0x80
+    #endif
+    #ifndef CO_ASYNC_GENERATOR
+      #define CO_ASYNC_GENERATOR 0x200
+    #endif
+#endif
+static int __Pyx_init_co_variables(void);
+#if PY_VERSION_HEX >= 0x030900A4 || defined(Py_IS_TYPE)
+  #define __Pyx_IS_TYPE(ob, type) Py_IS_TYPE(ob, type)
+#else
+  #define __Pyx_IS_TYPE(ob, type) (((const PyObject*)ob)->ob_type == (type))
+#endif
+#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_Is)
+  #define __Pyx_Py_Is(x, y)  Py_Is(x, y)
+#else
+  #define __Pyx_Py_Is(x, y) ((x) == (y))
+#endif
+#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsNone)
+  #define __Pyx_Py_IsNone(ob) Py_IsNone(ob)
+#else
+  #define __Pyx_Py_IsNone(ob) __Pyx_Py_Is((ob), Py_None)
+#endif
+#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsTrue)
+  #define __Pyx_Py_IsTrue(ob) Py_IsTrue(ob)
+#else
+  #define __Pyx_Py_IsTrue(ob) __Pyx_Py_Is((ob), Py_True)
+#endif
+#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsFalse)
+  #define __Pyx_Py_IsFalse(ob) Py_IsFalse(ob)
+#else
+  #define __Pyx_Py_IsFalse(ob) __Pyx_Py_Is((ob), Py_False)
+#endif
+#define __Pyx_NoneAsNull(obj)  (__Pyx_Py_IsNone(obj) ? NULL : (obj))
+#if PY_VERSION_HEX >= 0x030900F0 && !CYTHON_COMPILING_IN_PYPY
+  #define __Pyx_PyObject_GC_IsFinalized(o) PyObject_GC_IsFinalized(o)
+#else
+  #define __Pyx_PyObject_GC_IsFinalized(o) _PyGC_FINALIZED(o)
 #endif
 #ifndef Py_TPFLAGS_CHECKTYPES
   #define Py_TPFLAGS_CHECKTYPES 0
@@ -326,10 +627,16 @@
 #ifndef Py_TPFLAGS_HAVE_FINALIZE
   #define Py_TPFLAGS_HAVE_FINALIZE 0
 #endif
+#ifndef Py_TPFLAGS_SEQUENCE
+  #define Py_TPFLAGS_SEQUENCE 0
+#endif
+#ifndef Py_TPFLAGS_MAPPING
+  #define Py_TPFLAGS_MAPPING 0
+#endif
 #ifndef METH_STACKLESS
   #define METH_STACKLESS 0
 #endif
-#if PY_VERSION_HEX <= 0x030700A3 || !defined(METH_FASTCALL)
+#ifndef METH_FASTCALL
   #ifndef METH_FASTCALL
      #define METH_FASTCALL 0x80
   #endif
@@ -337,134 +644,208 @@
   typedef PyObject *(*__Pyx_PyCFunctionFastWithKeywords) (PyObject *self, PyObject *const *args,
                                                           Py_ssize_t nargs, PyObject *kwnames);
 #else
-  #define __Pyx_PyCFunctionFast _PyCFunctionFast
-  #define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords
+  #if PY_VERSION_HEX >= 0x030d00A4
+  #  define __Pyx_PyCFunctionFast PyCFunctionFast
+  #  define __Pyx_PyCFunctionFastWithKeywords PyCFunctionFastWithKeywords
+  #else
+  #  define __Pyx_PyCFunctionFast _PyCFunctionFast
+  #  define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords
+  #endif
 #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 | METH_KEYWORDS | METH_STACKLESS)))))
+#if CYTHON_METH_FASTCALL
+  #define __Pyx_METH_FASTCALL METH_FASTCALL
+  #define __Pyx_PyCFunction_FastCall __Pyx_PyCFunctionFast
+  #define __Pyx_PyCFunction_FastCallWithKeywords __Pyx_PyCFunctionFastWithKeywords
 #else
-#define __Pyx_PyFastCFunction_Check(func) 0
+  #define __Pyx_METH_FASTCALL METH_VARARGS
+  #define __Pyx_PyCFunction_FastCall PyCFunction
+  #define __Pyx_PyCFunction_FastCallWithKeywords PyCFunctionWithKeywords
 #endif
-#if CYTHON_USE_DICT_VERSIONS
-#define __PYX_GET_DICT_VERSION(dict)  (((PyDictObject*)(dict))->ma_version_tag)
-#define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var)\
-    (version_var) = __PYX_GET_DICT_VERSION(dict);\
-    (cache_var) = (value);
-#define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) {\
-        static PY_UINT64_T __pyx_dict_version = 0;\
-        static PyObject *__pyx_dict_cached_value = NULL;\
-        if (likely(__PYX_GET_DICT_VERSION(DICT) == __pyx_dict_version)) {\
-            (VAR) = __pyx_dict_cached_value;\
-        } else {\
-            (VAR) = __pyx_dict_cached_value = (LOOKUP);\
-            __pyx_dict_version = __PYX_GET_DICT_VERSION(DICT);\
-        }\
-    }
+#if CYTHON_VECTORCALL
+  #define __pyx_vectorcallfunc vectorcallfunc
+  #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET  PY_VECTORCALL_ARGUMENTS_OFFSET
+  #define __Pyx_PyVectorcall_NARGS(n)  PyVectorcall_NARGS((size_t)(n))
+#elif CYTHON_BACKPORT_VECTORCALL
+  typedef PyObject *(*__pyx_vectorcallfunc)(PyObject *callable, PyObject *const *args,
+                                            size_t nargsf, PyObject *kwnames);
+  #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET  ((size_t)1 << (8 * sizeof(size_t) - 1))
+  #define __Pyx_PyVectorcall_NARGS(n)  ((Py_ssize_t)(((size_t)(n)) & ~__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET))
 #else
-#define __PYX_GET_DICT_VERSION(dict)  (0)
-#define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var)
-#define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP)  (VAR) = (LOOKUP);
+  #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET  0
+  #define __Pyx_PyVectorcall_NARGS(n)  ((Py_ssize_t)(n))
+#endif
+#if PY_VERSION_HEX >= 0x030900B1
+#define __Pyx_PyCFunction_CheckExact(func)  PyCFunction_CheckExact(func)
+#else
+#define __Pyx_PyCFunction_CheckExact(func)  PyCFunction_Check(func)
+#endif
+#define __Pyx_CyOrPyCFunction_Check(func)  PyCFunction_Check(func)
+#if CYTHON_COMPILING_IN_CPYTHON
+#define __Pyx_CyOrPyCFunction_GET_FUNCTION(func)  (((PyCFunctionObject*)(func))->m_ml->ml_meth)
+#elif !CYTHON_COMPILING_IN_LIMITED_API
+#define __Pyx_CyOrPyCFunction_GET_FUNCTION(func)  PyCFunction_GET_FUNCTION(func)
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON
+#define __Pyx_CyOrPyCFunction_GET_FLAGS(func)  (((PyCFunctionObject*)(func))->m_ml->ml_flags)
+static CYTHON_INLINE PyObject* __Pyx_CyOrPyCFunction_GET_SELF(PyObject *func) {
+    return (__Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_STATIC) ? NULL : ((PyCFunctionObject*)func)->m_self;
+}
+#endif
+static CYTHON_INLINE int __Pyx__IsSameCFunction(PyObject *func, void (*cfunc)(void)) {
+#if CYTHON_COMPILING_IN_LIMITED_API
+    return PyCFunction_Check(func) && PyCFunction_GetFunction(func) == (PyCFunction) cfunc;
+#else
+    return PyCFunction_Check(func) && PyCFunction_GET_FUNCTION(func) == (PyCFunction) cfunc;
+#endif
+}
+#define __Pyx_IsSameCFunction(func, cfunc)   __Pyx__IsSameCFunction(func, cfunc)
+#if __PYX_LIMITED_VERSION_HEX < 0x03090000
+  #define __Pyx_PyType_FromModuleAndSpec(m, s, b)  ((void)m, PyType_FromSpecWithBases(s, b))
+  typedef PyObject *(*__Pyx_PyCMethod)(PyObject *, PyTypeObject *, PyObject *const *, size_t, PyObject *);
+#else
+  #define __Pyx_PyType_FromModuleAndSpec(m, s, b)  PyType_FromModuleAndSpec(m, s, b)
+  #define __Pyx_PyCMethod  PyCMethod
+#endif
+#ifndef METH_METHOD
+  #define METH_METHOD 0x200
 #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_CPYTHON && PY_VERSION_HEX < 0x030400A1
-  #define PyMem_RawMalloc(n)           PyMem_Malloc(n)
-  #define PyMem_RawRealloc(p, n)       PyMem_Realloc(p, n)
-  #define PyMem_RawFree(p)             PyMem_Free(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)
+#if CYTHON_COMPILING_IN_LIMITED_API
+  #define __Pyx_PyFrame_SetLineNumber(frame, lineno)
+#elif CYTHON_COMPILING_IN_GRAAL
+  #define __Pyx_PyCode_HasFreeVars(co)  (PyCode_GetNumFree(co) > 0)
+  #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
-#if !CYTHON_FAST_THREAD_STATE || PY_VERSION_HEX < 0x02070000
-  #define __Pyx_PyThreadState_Current PyThreadState_GET()
-#elif PY_VERSION_HEX >= 0x03060000
-  #define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet()
-#elif PY_VERSION_HEX >= 0x03000000
+#if CYTHON_COMPILING_IN_LIMITED_API
+  #define __Pyx_PyThreadState_Current PyThreadState_Get()
+#elif !CYTHON_FAST_THREAD_STATE
   #define __Pyx_PyThreadState_Current PyThreadState_GET()
+#elif PY_VERSION_HEX >= 0x030d00A1
+  #define __Pyx_PyThreadState_Current PyThreadState_GetUnchecked()
 #else
-  #define __Pyx_PyThreadState_Current _PyThreadState_Current
+  #define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet()
 #endif
-#if PY_VERSION_HEX < 0x030700A2 && !defined(PyThread_tss_create) && !defined(Py_tss_NEEDS_INIT)
-#include "pythread.h"
-#define Py_tss_NEEDS_INIT 0
-typedef int Py_tss_t;
-static CYTHON_INLINE int PyThread_tss_create(Py_tss_t *key) {
-  *key = PyThread_create_key();
-  return 0; // PyThread_create_key reports success always
-}
-static CYTHON_INLINE Py_tss_t * PyThread_tss_alloc(void) {
-  Py_tss_t *key = (Py_tss_t *)PyObject_Malloc(sizeof(Py_tss_t));
-  *key = Py_tss_NEEDS_INIT;
-  return key;
-}
-static CYTHON_INLINE void PyThread_tss_free(Py_tss_t *key) {
-  PyObject_Free(key);
-}
-static CYTHON_INLINE int PyThread_tss_is_created(Py_tss_t *key) {
-  return *key != Py_tss_NEEDS_INIT;
-}
-static CYTHON_INLINE void PyThread_tss_delete(Py_tss_t *key) {
-  PyThread_delete_key(*key);
-  *key = Py_tss_NEEDS_INIT;
-}
-static CYTHON_INLINE int PyThread_tss_set(Py_tss_t *key, void *value) {
-  return PyThread_set_key_value(*key, value);
-}
-static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
-  return PyThread_get_key_value(*key);
+#if CYTHON_USE_MODULE_STATE
+static CYTHON_INLINE void *__Pyx__PyModule_GetState(PyObject *op)
+{
+    void *result;
+    result = PyModule_GetState(op);
+    if (!result)
+        Py_FatalError("Couldn't find the module state");
+    return result;
 }
-#endif // TSS (Thread Specific Storage) API
+#define __Pyx_PyModule_GetState(o) (__pyx_mstatetype *)__Pyx__PyModule_GetState(o)
+#else
+#define __Pyx_PyModule_GetState(op) ((void)op,__pyx_mstate_global)
+#endif
+#define __Pyx_PyObject_GetSlot(obj, name, func_ctype)  __Pyx_PyType_GetSlot(Py_TYPE((PyObject *) obj), name, func_ctype)
+#define __Pyx_PyObject_TryGetSlot(obj, name, func_ctype) __Pyx_PyType_TryGetSlot(Py_TYPE(obj), name, func_ctype)
+#define __Pyx_PyObject_GetSubSlot(obj, sub, name, func_ctype) __Pyx_PyType_GetSubSlot(Py_TYPE(obj), sub, name, func_ctype)
+#define __Pyx_PyObject_TryGetSubSlot(obj, sub, name, func_ctype) __Pyx_PyType_TryGetSubSlot(Py_TYPE(obj), sub, name, func_ctype)
+#if CYTHON_USE_TYPE_SLOTS
+  #define __Pyx_PyType_GetSlot(type, name, func_ctype)  ((type)->name)
+  #define __Pyx_PyType_TryGetSlot(type, name, func_ctype) __Pyx_PyType_GetSlot(type, name, func_ctype)
+  #define __Pyx_PyType_GetSubSlot(type, sub, name, func_ctype) (((type)->sub) ? ((type)->sub->name) : NULL)
+  #define __Pyx_PyType_TryGetSubSlot(type, sub, name, func_ctype) __Pyx_PyType_GetSubSlot(type, sub, name, func_ctype)
+#else
+  #define __Pyx_PyType_GetSlot(type, name, func_ctype)  ((func_ctype) PyType_GetSlot((type), Py_##name))
+  #define __Pyx_PyType_TryGetSlot(type, name, func_ctype)\
+    ((__PYX_LIMITED_VERSION_HEX >= 0x030A0000 ||\
+     (PyType_GetFlags(type) & Py_TPFLAGS_HEAPTYPE) || __Pyx_get_runtime_version() >= 0x030A0000) ?\
+     __Pyx_PyType_GetSlot(type, name, func_ctype) : NULL)
+  #define __Pyx_PyType_GetSubSlot(obj, sub, name, func_ctype) __Pyx_PyType_GetSlot(obj, name, func_ctype)
+  #define __Pyx_PyType_TryGetSubSlot(obj, sub, name, func_ctype) __Pyx_PyType_TryGetSlot(obj, name, func_ctype)
+#endif
 #if CYTHON_COMPILING_IN_CPYTHON || defined(_PyDict_NewPresized)
 #define __Pyx_PyDict_NewPresized(n)  ((n <= 8) ? PyDict_New() : _PyDict_NewPresized(n))
 #else
 #define __Pyx_PyDict_NewPresized(n)  PyDict_New()
 #endif
-#if PY_MAJOR_VERSION >= 3 || CYTHON_FUTURE_DIVISION
-  #define __Pyx_PyNumber_Divide(x,y)         PyNumber_TrueDivide(x,y)
-  #define __Pyx_PyNumber_InPlaceDivide(x,y)  PyNumber_InPlaceTrueDivide(x,y)
+#define __Pyx_PyNumber_Divide(x,y)         PyNumber_TrueDivide(x,y)
+#define __Pyx_PyNumber_InPlaceDivide(x,y)  PyNumber_InPlaceTrueDivide(x,y)
+#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_UNICODE_INTERNALS
+#define __Pyx_PyDict_GetItemStrWithError(dict, name)  _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash)
+static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStr(PyObject *dict, PyObject *name) {
+    PyObject *res = __Pyx_PyDict_GetItemStrWithError(dict, name);
+    if (res == NULL) PyErr_Clear();
+    return res;
+}
+#elif !CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07020000
+#define __Pyx_PyDict_GetItemStrWithError  PyDict_GetItemWithError
+#define __Pyx_PyDict_GetItemStr           PyDict_GetItem
+#else
+static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStrWithError(PyObject *dict, PyObject *name) {
+#if CYTHON_COMPILING_IN_PYPY
+    return PyDict_GetItem(dict, name);
+#else
+    PyDictEntry *ep;
+    PyDictObject *mp = (PyDictObject*) dict;
+    long hash = ((PyStringObject *) name)->ob_shash;
+    assert(hash != -1);
+    ep = (mp->ma_lookup)(mp, name, hash);
+    if (ep == NULL) {
+        return NULL;
+    }
+    return ep->me_value;
+#endif
+}
+#define __Pyx_PyDict_GetItemStr           PyDict_GetItem
+#endif
+#if CYTHON_USE_TYPE_SLOTS
+  #define __Pyx_PyType_GetFlags(tp)   (((PyTypeObject *)tp)->tp_flags)
+  #define __Pyx_PyType_HasFeature(type, feature)  ((__Pyx_PyType_GetFlags(type) & (feature)) != 0)
 #else
-  #define __Pyx_PyNumber_Divide(x,y)         PyNumber_Divide(x,y)
-  #define __Pyx_PyNumber_InPlaceDivide(x,y)  PyNumber_InPlaceDivide(x,y)
+  #define __Pyx_PyType_GetFlags(tp)   (PyType_GetFlags((PyTypeObject *)tp))
+  #define __Pyx_PyType_HasFeature(type, feature)  PyType_HasFeature(type, feature)
 #endif
-#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 && CYTHON_USE_UNICODE_INTERNALS
-#define __Pyx_PyDict_GetItemStr(dict, name)  _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash)
+#define __Pyx_PyObject_GetIterNextFunc(iterator)  __Pyx_PyObject_GetSlot(iterator, tp_iternext, iternextfunc)
+#if CYTHON_USE_TYPE_SPECS && PY_VERSION_HEX >= 0x03080000
+#define __Pyx_PyHeapTypeObject_GC_Del(obj)  {\
+    PyTypeObject *type = Py_TYPE((PyObject*)obj);\
+    assert(__Pyx_PyType_HasFeature(type, Py_TPFLAGS_HEAPTYPE));\
+    PyObject_GC_Del(obj);\
+    Py_DECREF(type);\
+}
 #else
-#define __Pyx_PyDict_GetItemStr(dict, name)  PyDict_GetItem(dict, name)
+#define __Pyx_PyHeapTypeObject_GC_Del(obj)  PyObject_GC_Del(obj)
 #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)
+#if CYTHON_COMPILING_IN_LIMITED_API
+  #define __Pyx_PyUnicode_READY(op)       (0)
+  #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_ReadChar(u, i)
+  #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u)   ((void)u, 1114111U)
+  #define __Pyx_PyUnicode_KIND(u)         ((void)u, (0))
+  #define __Pyx_PyUnicode_DATA(u)         ((void*)u)
+  #define __Pyx_PyUnicode_READ(k, d, i)   ((void)k, PyUnicode_ReadChar((PyObject*)(d), i))
+  #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != PyUnicode_GetLength(u))
+#else
+  #if PY_VERSION_HEX >= 0x030C0000
+    #define __Pyx_PyUnicode_READY(op)       (0)
+  #else
+    #define __Pyx_PyUnicode_READY(op)       (likely(PyUnicode_IS_READY(op)) ?\
+                                                0 : _PyUnicode_Ready((PyObject *)(op)))
+  #endif
   #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_KIND(u)         ((int)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))
+  #define __Pyx_PyUnicode_WRITE(k, d, i, ch)  PyUnicode_WRITE(k, d, i, (Py_UCS4) ch)
+  #if PY_VERSION_HEX >= 0x030C0000
+    #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != PyUnicode_GET_LENGTH(u))
+  #else
+    #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03090000
+    #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : ((PyCompactUnicodeObject *)(u))->wstr_length))
+    #else
+    #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u)))
+    #endif
+  #endif
 #endif
 #if CYTHON_COMPILING_IN_PYPY
   #define __Pyx_PyUnicode_Concat(a, b)      PyNumber_Add(a, b)
@@ -474,106 +855,226 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #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)
+#if CYTHON_COMPILING_IN_PYPY
+  #if !defined(PyUnicode_DecodeUnicodeEscape)
+    #define PyUnicode_DecodeUnicodeEscape(s, size, errors)  PyUnicode_Decode(s, size, "unicode_escape", errors)
+  #endif
+  #if !defined(PyUnicode_Contains)
+    #define PyUnicode_Contains(u, s)  PySequence_Contains(u, s)
+  #endif
+  #if !defined(PyByteArray_Check)
+    #define PyByteArray_Check(obj)  PyObject_TypeCheck(obj, &PyByteArray_Type)
+  #endif
+  #if !defined(PyObject_Format)
+    #define PyObject_Format(obj, fmt)  PyObject_CallMethod(obj, "__format__", "O", fmt)
+  #endif
 #endif
-#define __Pyx_PyString_FormatSafe(a, b)   ((unlikely((a) == Py_None || (PyString_Check(b) && !PyString_CheckExact(b)))) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b))
 #define __Pyx_PyUnicode_FormatSafe(a, b)  ((unlikely((a) == Py_None || (PyUnicode_Check(b) && !PyUnicode_CheckExact(b)))) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b))
-#if PY_MAJOR_VERSION >= 3
-  #define __Pyx_PyString_Format(a, b)  PyUnicode_Format(a, b)
+#if CYTHON_COMPILING_IN_CPYTHON
+  #define __Pyx_PySequence_ListKeepNew(obj)\
+    (likely(PyList_CheckExact(obj) && Py_REFCNT(obj) == 1) ? __Pyx_NewRef(obj) : PySequence_List(obj))
 #else
-  #define __Pyx_PyString_Format(a, b)  PyString_Format(a, b)
+  #define __Pyx_PySequence_ListKeepNew(obj)  PySequence_List(obj)
+#endif
+#ifndef PySet_CheckExact
+  #define PySet_CheckExact(obj)        __Pyx_IS_TYPE(obj, &PySet_Type)
 #endif
-#if PY_MAJOR_VERSION < 3 && !defined(PyObject_ASCII)
-  #define PyObject_ASCII(o)            PyObject_Repr(o)
+#if PY_VERSION_HEX >= 0x030900A4
+  #define __Pyx_SET_REFCNT(obj, refcnt) Py_SET_REFCNT(obj, refcnt)
+  #define __Pyx_SET_SIZE(obj, size) Py_SET_SIZE(obj, size)
+#else
+  #define __Pyx_SET_REFCNT(obj, refcnt) Py_REFCNT(obj) = (refcnt)
+  #define __Pyx_SET_SIZE(obj, size) Py_SIZE(obj) = (size)
 #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
-  #define PyObject_Unicode             PyObject_Str
+#if CYTHON_AVOID_BORROWED_REFS || CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS
+  #if __PYX_LIMITED_VERSION_HEX >= 0x030d0000
+    #define __Pyx_PyList_GetItemRef(o, i) PyList_GetItemRef(o, i)
+  #elif CYTHON_COMPILING_IN_LIMITED_API || !CYTHON_ASSUME_SAFE_MACROS
+    #define __Pyx_PyList_GetItemRef(o, i) (likely((i) >= 0) ? PySequence_GetItem(o, i) : (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL))
+  #else
+    #define __Pyx_PyList_GetItemRef(o, i) PySequence_ITEM(o, i)
+  #endif
+#elif CYTHON_COMPILING_IN_LIMITED_API || !CYTHON_ASSUME_SAFE_MACROS
+  #if __PYX_LIMITED_VERSION_HEX >= 0x030d0000
+    #define __Pyx_PyList_GetItemRef(o, i) PyList_GetItemRef(o, i)
+  #else
+    #define __Pyx_PyList_GetItemRef(o, i) __Pyx_XNewRef(PyList_GetItem(o, i))
+  #endif
+#else
+  #define __Pyx_PyList_GetItemRef(o, i) __Pyx_NewRef(PyList_GET_ITEM(o, i))
 #endif
-#if PY_MAJOR_VERSION >= 3
-  #define __Pyx_PyBaseString_Check(obj) PyUnicode_Check(obj)
-  #define __Pyx_PyBaseString_CheckExact(obj) PyUnicode_CheckExact(obj)
+#if __PYX_LIMITED_VERSION_HEX >= 0x030d0000
+#define __Pyx_PyDict_GetItemRef(dict, key, result) PyDict_GetItemRef(dict, key, result)
+#elif CYTHON_AVOID_BORROWED_REFS || CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS
+static CYTHON_INLINE int __Pyx_PyDict_GetItemRef(PyObject *dict, PyObject *key, PyObject **result) {
+  *result = PyObject_GetItem(dict, key);
+  if (*result == NULL) {
+    if (PyErr_ExceptionMatches(PyExc_KeyError)) {
+      PyErr_Clear();
+      return 0;
+    }
+    return -1;
+  }
+  return 1;
+}
 #else
-  #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj))
-  #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj))
+static CYTHON_INLINE int __Pyx_PyDict_GetItemRef(PyObject *dict, PyObject *key, PyObject **result) {
+  *result = PyDict_GetItemWithError(dict, key);
+  if (*result == NULL) {
+    return PyErr_Occurred() ? -1 : 0;
+  }
+  Py_INCREF(*result);
+  return 1;
+}
 #endif
-#ifndef PySet_CheckExact
-  #define PySet_CheckExact(obj)        (Py_TYPE(obj) == &PySet_Type)
+#if defined(CYTHON_DEBUG_VISIT_CONST) && CYTHON_DEBUG_VISIT_CONST
+  #define __Pyx_VISIT_CONST(obj)  Py_VISIT(obj)
+#else
+  #define __Pyx_VISIT_CONST(obj)
 #endif
 #if CYTHON_ASSUME_SAFE_MACROS
+  #define __Pyx_PySequence_ITEM(o, i) PySequence_ITEM(o, i)
   #define __Pyx_PySequence_SIZE(seq)  Py_SIZE(seq)
+  #define __Pyx_PyTuple_SET_ITEM(o, i, v) (PyTuple_SET_ITEM(o, i, v), (0))
+  #define __Pyx_PyTuple_GET_ITEM(o, i) PyTuple_GET_ITEM(o, i)
+  #define __Pyx_PyList_SET_ITEM(o, i, v) (PyList_SET_ITEM(o, i, v), (0))
+  #define __Pyx_PyList_GET_ITEM(o, i) PyList_GET_ITEM(o, i)
 #else
+  #define __Pyx_PySequence_ITEM(o, i) PySequence_GetItem(o, i)
   #define __Pyx_PySequence_SIZE(seq)  PySequence_Size(seq)
+  #define __Pyx_PyTuple_SET_ITEM(o, i, v) PyTuple_SetItem(o, i, v)
+  #define __Pyx_PyTuple_GET_ITEM(o, i) PyTuple_GetItem(o, i)
+  #define __Pyx_PyList_SET_ITEM(o, i, v) PyList_SetItem(o, i, v)
+  #define __Pyx_PyList_GET_ITEM(o, i) PyList_GetItem(o, i)
 #endif
-#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) : (Py_INCREF(func), 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
-    #define __Pyx_PyType_AsAsync(obj) ((__Pyx_PyAsyncMethodsStruct*) (Py_TYPE(obj)->tp_reserved))
-  #endif
+#if CYTHON_ASSUME_SAFE_SIZE
+  #define __Pyx_PyTuple_GET_SIZE(o) PyTuple_GET_SIZE(o)
+  #define __Pyx_PyList_GET_SIZE(o) PyList_GET_SIZE(o)
+  #define __Pyx_PySet_GET_SIZE(o) PySet_GET_SIZE(o)
+  #define __Pyx_PyBytes_GET_SIZE(o) PyBytes_GET_SIZE(o)
+  #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_GET_SIZE(o)
+  #define __Pyx_PyUnicode_GET_LENGTH(o) PyUnicode_GET_LENGTH(o)
+#else
+  #define __Pyx_PyTuple_GET_SIZE(o) PyTuple_Size(o)
+  #define __Pyx_PyList_GET_SIZE(o) PyList_Size(o)
+  #define __Pyx_PySet_GET_SIZE(o) PySet_Size(o)
+  #define __Pyx_PyBytes_GET_SIZE(o) PyBytes_Size(o)
+  #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_Size(o)
+  #define __Pyx_PyUnicode_GET_LENGTH(o) PyUnicode_GetLength(o)
+#endif
+#if __PYX_LIMITED_VERSION_HEX >= 0x030d0000
+  #define __Pyx_PyImport_AddModuleRef(name) PyImport_AddModuleRef(name)
+#else
+  static CYTHON_INLINE PyObject *__Pyx_PyImport_AddModuleRef(const char *name) {
+      PyObject *module = PyImport_AddModule(name);
+      Py_XINCREF(module);
+      return module;
+  }
+#endif
+#if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_InternFromString)
+  #define PyUnicode_InternFromString(s) PyUnicode_FromString(s)
+#endif
+#define __Pyx_PyLong_FromHash_t PyLong_FromSsize_t
+#define __Pyx_PyLong_AsHash_t   __Pyx_PyIndex_AsSsize_t
+#if __PYX_LIMITED_VERSION_HEX >= 0x030A0000
+    #define __Pyx_PySendResult PySendResult
 #else
-  #define __Pyx_PyType_AsAsync(obj) NULL
+    typedef enum {
+        PYGEN_RETURN = 0,
+        PYGEN_ERROR = -1,
+        PYGEN_NEXT = 1,
+    } __Pyx_PySendResult;
 #endif
-#ifndef __Pyx_PyAsyncMethodsStruct
+#if CYTHON_COMPILING_IN_LIMITED_API || PY_VERSION_HEX < 0x030A00A3
+  typedef __Pyx_PySendResult (*__Pyx_pyiter_sendfunc)(PyObject *iter, PyObject *value, PyObject **result);
+#else
+  #define __Pyx_pyiter_sendfunc sendfunc
+#endif
+#if !CYTHON_USE_AM_SEND
+#define __PYX_HAS_PY_AM_SEND 0
+#elif __PYX_LIMITED_VERSION_HEX >= 0x030A0000
+#define __PYX_HAS_PY_AM_SEND 1
+#else
+#define __PYX_HAS_PY_AM_SEND 2  // our own backported implementation
+#endif
+#if __PYX_HAS_PY_AM_SEND < 2
+    #define __Pyx_PyAsyncMethodsStruct PyAsyncMethods
+#else
     typedef struct {
         unaryfunc am_await;
         unaryfunc am_aiter;
         unaryfunc am_anext;
+        __Pyx_pyiter_sendfunc am_send;
     } __Pyx_PyAsyncMethodsStruct;
+    #define __Pyx_SlotTpAsAsync(s) ((PyAsyncMethods*)(s))
+#endif
+#if CYTHON_USE_AM_SEND && PY_VERSION_HEX < 0x030A00F0
+    #define __Pyx_TPFLAGS_HAVE_AM_SEND (1UL << 21)
+#else
+    #define __Pyx_TPFLAGS_HAVE_AM_SEND (0)
+#endif
+#if PY_VERSION_HEX >= 0x03090000
+#define __Pyx_PyInterpreterState_Get() PyInterpreterState_Get()
+#else
+#define __Pyx_PyInterpreterState_Get() PyThreadState_Get()->interp
+#endif
+#if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030A0000
+#ifdef __cplusplus
+extern "C"
+#endif
+PyAPI_FUNC(void *) PyMem_Calloc(size_t nelem, size_t elsize);
+#endif
+#if CYTHON_COMPILING_IN_LIMITED_API
+static int __Pyx_init_co_variable(PyObject *inspect, const char* name, int *write_to) {
+    int value;
+    PyObject *py_value = PyObject_GetAttrString(inspect, name);
+    if (!py_value) return 0;
+    value = (int) PyLong_AsLong(py_value);
+    Py_DECREF(py_value);
+    *write_to = value;
+    return value != -1 || !PyErr_Occurred();
+}
+static int __Pyx_init_co_variables(void) {
+    PyObject *inspect;
+    int result;
+    inspect = PyImport_ImportModule("inspect");
+    result =
+#if !defined(CO_OPTIMIZED)
+        __Pyx_init_co_variable(inspect, "CO_OPTIMIZED", &CO_OPTIMIZED) &&
+#endif
+#if !defined(CO_NEWLOCALS)
+        __Pyx_init_co_variable(inspect, "CO_NEWLOCALS", &CO_NEWLOCALS) &&
+#endif
+#if !defined(CO_VARARGS)
+        __Pyx_init_co_variable(inspect, "CO_VARARGS", &CO_VARARGS) &&
+#endif
+#if !defined(CO_VARKEYWORDS)
+        __Pyx_init_co_variable(inspect, "CO_VARKEYWORDS", &CO_VARKEYWORDS) &&
+#endif
+#if !defined(CO_ASYNC_GENERATOR)
+        __Pyx_init_co_variable(inspect, "CO_ASYNC_GENERATOR", &CO_ASYNC_GENERATOR) &&
+#endif
+#if !defined(CO_GENERATOR)
+        __Pyx_init_co_variable(inspect, "CO_GENERATOR", &CO_GENERATOR) &&
+#endif
+#if !defined(CO_COROUTINE)
+        __Pyx_init_co_variable(inspect, "CO_COROUTINE", &CO_COROUTINE) &&
+#endif
+        1;
+    Py_DECREF(inspect);
+    return result ? 0 : -1;
+}
+#else
+static int __Pyx_init_co_variables(void) {
+    return 0;  // It's a limited API-only feature
+}
 #endif
 
-#if defined(WIN32) || defined(MS_WINDOWS)
-  #define _USE_MATH_DEFINES
+/* MathInitCode */
+#if defined(_WIN32) || defined(WIN32) || defined(MS_WINDOWS)
+  #ifndef _USE_MATH_DEFINES
+    #define _USE_MATH_DEFINES
+  #endif
 #endif
 #include <math.h>
 #ifdef NAN
@@ -591,13 +1092,30 @@ static CYTHON_INLINE float __PYX_NAN() {
 #define __Pyx_truncl truncl
 #endif
 
-
+#ifndef CYTHON_CLINE_IN_TRACEBACK_RUNTIME
+#define CYTHON_CLINE_IN_TRACEBACK_RUNTIME 0
+#endif
+#ifndef CYTHON_CLINE_IN_TRACEBACK
+#define CYTHON_CLINE_IN_TRACEBACK CYTHON_CLINE_IN_TRACEBACK_RUNTIME
+#endif
+#if CYTHON_CLINE_IN_TRACEBACK
+#define __PYX_MARK_ERR_POS(f_index, lineno)  { __pyx_filename = __pyx_f[f_index]; (void) __pyx_filename; __pyx_lineno = lineno; (void) __pyx_lineno; __pyx_clineno = __LINE__; (void) __pyx_clineno; }
+#else
+#define __PYX_MARK_ERR_POS(f_index, lineno)  { __pyx_filename = __pyx_f[f_index]; (void) __pyx_filename; __pyx_lineno = lineno; (void) __pyx_lineno; (void) __pyx_clineno; }
+#endif
 #define __PYX_ERR(f_index, lineno, Ln_error) \
-{ \
-  __pyx_filename = __pyx_f[f_index]; __pyx_lineno = lineno; __pyx_clineno = __LINE__; goto Ln_error; \
-}
-
-#ifndef __PYX_EXTERN_C
+    { __PYX_MARK_ERR_POS(f_index, lineno) goto Ln_error; }
+
+#ifdef CYTHON_EXTERN_C
+    #undef __PYX_EXTERN_C
+    #define __PYX_EXTERN_C CYTHON_EXTERN_C
+#elif defined(__PYX_EXTERN_C)
+    #ifdef _MSC_VER
+    #pragma message ("Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead.")
+    #else
+    #warning Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead.
+    #endif
+#else
   #ifdef __cplusplus
     #define __PYX_EXTERN_C extern "C"
   #else
@@ -618,7 +1136,13 @@ static CYTHON_INLINE float __PYX_NAN() {
 #endif
 #include <string.h>
 #include <stdio.h>
+
+    /* Using NumPy API declarations from "numpy/__init__.cython-30.pxd" */
+    
 #include "numpy/arrayobject.h"
+#include "numpy/ndarrayobject.h"
+#include "numpy/ndarraytypes.h"
+#include "numpy/arrayscalars.h"
 #include "numpy/ufuncobject.h"
 #ifdef _OPENMP
 #include <omp.h>
@@ -628,11 +1152,8 @@ static CYTHON_INLINE float __PYX_NAN() {
 #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_IS_UTF8 0
 #define __PYX_DEFAULT_STRING_ENCODING ""
 #define __Pyx_PyObject_FromString __Pyx_PyBytes_FromString
 #define __Pyx_PyObject_FromStringAndSize __Pyx_PyBytes_FromStringAndSize
@@ -667,139 +1188,130 @@ static CYTHON_INLINE int __Pyx_is_valid_index(Py_ssize_t i, Py_ssize_t limit) {
 #else
     #define __Pyx_sst_abs(value) ((value<0) ? -value : value)
 #endif
+static CYTHON_INLINE Py_ssize_t __Pyx_ssize_strlen(const char *s);
 static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject*);
 static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length);
-#define __Pyx_PyByteArray_FromString(s) PyByteArray_FromStringAndSize((const char*)s, strlen((const char*)s))
+static CYTHON_INLINE PyObject* __Pyx_PyByteArray_FromString(const char*);
 #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_PyBytes_AsWritableString(s)     ((char*) PyBytes_AS_STRING(s))
-#define __Pyx_PyBytes_AsWritableSString(s)    ((signed char*) PyBytes_AS_STRING(s))
-#define __Pyx_PyBytes_AsWritableUString(s)    ((unsigned char*) PyBytes_AS_STRING(s))
-#define __Pyx_PyBytes_AsString(s)     ((const char*) PyBytes_AS_STRING(s))
-#define __Pyx_PyBytes_AsSString(s)    ((const signed char*) PyBytes_AS_STRING(s))
-#define __Pyx_PyBytes_AsUString(s)    ((const unsigned char*) PyBytes_AS_STRING(s))
-#define __Pyx_PyObject_AsWritableString(s)    ((char*) __Pyx_PyObject_AsString(s))
-#define __Pyx_PyObject_AsWritableSString(s)    ((signed char*) __Pyx_PyObject_AsString(s))
-#define __Pyx_PyObject_AsWritableUString(s)    ((unsigned char*) __Pyx_PyObject_AsString(s))
+#if CYTHON_ASSUME_SAFE_MACROS
+    #define __Pyx_PyBytes_AsWritableString(s)     ((char*) PyBytes_AS_STRING(s))
+    #define __Pyx_PyBytes_AsWritableSString(s)    ((signed char*) PyBytes_AS_STRING(s))
+    #define __Pyx_PyBytes_AsWritableUString(s)    ((unsigned char*) PyBytes_AS_STRING(s))
+    #define __Pyx_PyBytes_AsString(s)     ((const char*) PyBytes_AS_STRING(s))
+    #define __Pyx_PyBytes_AsSString(s)    ((const signed char*) PyBytes_AS_STRING(s))
+    #define __Pyx_PyBytes_AsUString(s)    ((const unsigned char*) PyBytes_AS_STRING(s))
+    #define __Pyx_PyByteArray_AsString(s) PyByteArray_AS_STRING(s)
+#else
+    #define __Pyx_PyBytes_AsWritableString(s)     ((char*) PyBytes_AsString(s))
+    #define __Pyx_PyBytes_AsWritableSString(s)    ((signed char*) PyBytes_AsString(s))
+    #define __Pyx_PyBytes_AsWritableUString(s)    ((unsigned char*) PyBytes_AsString(s))
+    #define __Pyx_PyBytes_AsString(s)     ((const char*) PyBytes_AsString(s))
+    #define __Pyx_PyBytes_AsSString(s)    ((const signed char*) PyBytes_AsString(s))
+    #define __Pyx_PyBytes_AsUString(s)    ((const unsigned char*) PyBytes_AsString(s))
+    #define __Pyx_PyByteArray_AsString(s) PyByteArray_AsString(s)
+#endif
+#define __Pyx_PyObject_AsWritableString(s)    ((char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s))
+#define __Pyx_PyObject_AsWritableSString(s)    ((signed char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s))
+#define __Pyx_PyObject_AsWritableUString(s)    ((unsigned char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s))
 #define __Pyx_PyObject_AsSString(s)    ((const signed char*) __Pyx_PyObject_AsString(s))
 #define __Pyx_PyObject_AsUString(s)    ((const 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)
-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);
-}
-#define __Pyx_PyUnicode_FromUnicode(u)       PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u))
-#define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode
+#define __Pyx_PyUnicode_FromOrdinal(o)       PyUnicode_FromOrdinal((int)o)
 #define __Pyx_PyUnicode_AsUnicode            PyUnicode_AsUnicode
-#define __Pyx_NewRef(obj) (Py_INCREF(obj), obj)
-#define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None)
+static CYTHON_INLINE PyObject *__Pyx_NewRef(PyObject *obj) {
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030a0000 || defined(Py_NewRef)
+    return Py_NewRef(obj);
+#else
+    Py_INCREF(obj);
+    return obj;
+#endif
+}
+static CYTHON_INLINE PyObject *__Pyx_XNewRef(PyObject *obj) {
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030a0000 || defined(Py_XNewRef)
+    return Py_XNewRef(obj);
+#else
+    Py_XINCREF(obj);
+    return obj;
+#endif
+}
+static CYTHON_INLINE PyObject *__Pyx_Owned_Py_None(int b);
 static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b);
 static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*);
 static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject*);
-static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x);
+static CYTHON_INLINE PyObject* __Pyx_PyNumber_Long(PyObject* x);
 #define __Pyx_PySequence_Tuple(obj)\
     (likely(PyTuple_CheckExact(obj)) ? __Pyx_NewRef(obj) : PySequence_Tuple(obj))
 static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*);
-static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t);
+static CYTHON_INLINE PyObject * __Pyx_PyLong_FromSize_t(size_t);
+static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject*);
 #if CYTHON_ASSUME_SAFE_MACROS
-#define __pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x))
+#define __Pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x))
+#define __Pyx_PyFloat_AS_DOUBLE(x) PyFloat_AS_DOUBLE(x)
 #else
-#define __pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x)
+#define __Pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x)
+#define __Pyx_PyFloat_AS_DOUBLE(x) PyFloat_AsDouble(x)
 #endif
-#define __pyx_PyFloat_AsFloat(x) ((float) __pyx_PyFloat_AsDouble(x))
-#if PY_MAJOR_VERSION >= 3
+#define __Pyx_PyFloat_AsFloat(x) ((float) __Pyx_PyFloat_AsDouble(x))
 #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) + 1);
-    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;
-}
+#if CYTHON_USE_PYLONG_INTERNALS
+  #if PY_VERSION_HEX >= 0x030C00A7
+  #ifndef _PyLong_SIGN_MASK
+    #define _PyLong_SIGN_MASK 3
+  #endif
+  #ifndef _PyLong_NON_SIZE_BITS
+    #define _PyLong_NON_SIZE_BITS 3
+  #endif
+  #define __Pyx_PyLong_Sign(x)  (((PyLongObject*)x)->long_value.lv_tag & _PyLong_SIGN_MASK)
+  #define __Pyx_PyLong_IsNeg(x)  ((__Pyx_PyLong_Sign(x) & 2) != 0)
+  #define __Pyx_PyLong_IsNonNeg(x)  (!__Pyx_PyLong_IsNeg(x))
+  #define __Pyx_PyLong_IsZero(x)  (__Pyx_PyLong_Sign(x) & 1)
+  #define __Pyx_PyLong_IsPos(x)  (__Pyx_PyLong_Sign(x) == 0)
+  #define __Pyx_PyLong_CompactValueUnsigned(x)  (__Pyx_PyLong_Digits(x)[0])
+  #define __Pyx_PyLong_DigitCount(x)  ((Py_ssize_t) (((PyLongObject*)x)->long_value.lv_tag >> _PyLong_NON_SIZE_BITS))
+  #define __Pyx_PyLong_SignedDigitCount(x)\
+        ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * __Pyx_PyLong_DigitCount(x))
+  #if defined(PyUnstable_Long_IsCompact) && defined(PyUnstable_Long_CompactValue)
+    #define __Pyx_PyLong_IsCompact(x)     PyUnstable_Long_IsCompact((PyLongObject*) x)
+    #define __Pyx_PyLong_CompactValue(x)  PyUnstable_Long_CompactValue((PyLongObject*) x)
+  #else
+    #define __Pyx_PyLong_IsCompact(x)     (((PyLongObject*)x)->long_value.lv_tag < (2 << _PyLong_NON_SIZE_BITS))
+    #define __Pyx_PyLong_CompactValue(x)  ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * (Py_ssize_t) __Pyx_PyLong_Digits(x)[0])
+  #endif
+  typedef Py_ssize_t  __Pyx_compact_pylong;
+  typedef size_t  __Pyx_compact_upylong;
+  #else
+  #define __Pyx_PyLong_IsNeg(x)  (Py_SIZE(x) < 0)
+  #define __Pyx_PyLong_IsNonNeg(x)  (Py_SIZE(x) >= 0)
+  #define __Pyx_PyLong_IsZero(x)  (Py_SIZE(x) == 0)
+  #define __Pyx_PyLong_IsPos(x)  (Py_SIZE(x) > 0)
+  #define __Pyx_PyLong_CompactValueUnsigned(x)  ((Py_SIZE(x) == 0) ? 0 : __Pyx_PyLong_Digits(x)[0])
+  #define __Pyx_PyLong_DigitCount(x)  __Pyx_sst_abs(Py_SIZE(x))
+  #define __Pyx_PyLong_SignedDigitCount(x)  Py_SIZE(x)
+  #define __Pyx_PyLong_IsCompact(x)  (Py_SIZE(x) == 0 || Py_SIZE(x) == 1 || Py_SIZE(x) == -1)
+  #define __Pyx_PyLong_CompactValue(x)\
+        ((Py_SIZE(x) == 0) ? (sdigit) 0 : ((Py_SIZE(x) < 0) ? -(sdigit)__Pyx_PyLong_Digits(x)[0] : (sdigit)__Pyx_PyLong_Digits(x)[0]))
+  typedef sdigit  __Pyx_compact_pylong;
+  typedef digit  __Pyx_compact_upylong;
+  #endif
+  static CYTHON_INLINE int __Pyx_PyLong_CompactAsLong(PyObject *x, long *return_value);
+  #if PY_VERSION_HEX >= 0x030C00A5
+  #define __Pyx_PyLong_Digits(x)  (((PyLongObject*)x)->long_value.ob_digit)
+  #else
+  #define __Pyx_PyLong_Digits(x)  (((PyLongObject*)x)->ob_digit)
+  #endif
 #endif
+#if __PYX_DEFAULT_STRING_ENCODING_IS_UTF8
+  #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL)
+#elif __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
+  #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeASCII(c_str, size, NULL)
+#else
+  #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL)
 #endif
 
 
@@ -811,25 +1323,37 @@ static int __Pyx_init_sys_getdefaultencoding_params(void) {
   #define likely(x)   (x)
   #define unlikely(x) (x)
 #endif /* __GNUC__ */
+/* PretendToInitialize */
+#ifdef __cplusplus
+#if __cplusplus > 201103L
+#include <type_traits>
+#endif
+template <typename T>
+static void __Pyx_pretend_to_initialize(T* ptr) {
+#if __cplusplus > 201103L
+    if ((std::is_trivially_default_constructible<T>::value))
+#endif
+        *ptr = T();
+    (void)ptr;
+}
+#else
 static CYTHON_INLINE void __Pyx_pretend_to_initialize(void* ptr) { (void)ptr; }
+#endif
+
 
+#if !CYTHON_USE_MODULE_STATE
 static PyObject *__pyx_m = NULL;
-static PyObject *__pyx_d;
-static PyObject *__pyx_b;
-static PyObject *__pyx_cython_runtime = NULL;
-static PyObject *__pyx_empty_tuple;
-static PyObject *__pyx_empty_bytes;
-static PyObject *__pyx_empty_unicode;
+#endif
 static int __pyx_lineno;
 static int __pyx_clineno = 0;
-static const char * __pyx_cfilenm= __FILE__;
+static const char * const __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)
+  #elif (defined(_Complex_I) && !defined(_MSC_VER)) || ((defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L) && !defined(__STDC_NO_COMPLEX__) && !defined(_MSC_VER))
     #define CYTHON_CCOMPLEX 1
   #else
     #define CYTHON_CCOMPLEX 0
@@ -847,16 +1371,178 @@ static const char *__pyx_filename;
   #define _Complex_I 1.0fj
 #endif
 
+/* #### Code section: filename_table ### */
 
-static const char *__pyx_f[] = {
+static const char* const __pyx_f[] = {
+  "talib/_ta_lib.pyx",
   "talib/_common.pxi",
   "talib/_abstract.pxi",
+  ".venv/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd",
   "talib/_func.pxi",
   "talib/_stream.pxi",
-  "__init__.pxd",
-  "talib/_ta_lib.pyx",
-  "type.pxd",
+  ".venv/lib/python3.12/site-packages/Cython/Includes/cpython/type.pxd",
 };
+/* #### Code section: utility_code_proto_before_types ### */
+/* Atomics.proto */
+#include <pythread.h>
+#ifndef CYTHON_ATOMICS
+    #define CYTHON_ATOMICS 1
+#endif
+#define __PYX_CYTHON_ATOMICS_ENABLED() CYTHON_ATOMICS
+#define __PYX_GET_CYTHON_COMPILING_IN_CPYTHON_FREETHREADING() CYTHON_COMPILING_IN_CPYTHON_FREETHREADING
+#define __pyx_atomic_int_type int
+#define __pyx_nonatomic_int_type int
+#if CYTHON_ATOMICS && (defined(__STDC_VERSION__) &&\
+                        (__STDC_VERSION__ >= 201112L) &&\
+                        !defined(__STDC_NO_ATOMICS__))
+    #include <stdatomic.h>
+#elif CYTHON_ATOMICS && (defined(__cplusplus) && (\
+                    (__cplusplus >= 201103L) ||\
+                    (defined(_MSC_VER) && _MSC_VER >= 1700)))
+    #include <atomic>
+#endif
+#if CYTHON_ATOMICS && (defined(__STDC_VERSION__) &&\
+                        (__STDC_VERSION__ >= 201112L) &&\
+                        !defined(__STDC_NO_ATOMICS__) &&\
+                       ATOMIC_INT_LOCK_FREE == 2)
+    #undef __pyx_atomic_int_type
+    #define __pyx_atomic_int_type atomic_int
+    #define __pyx_atomic_ptr_type atomic_uintptr_t
+    #define __pyx_nonatomic_ptr_type uintptr_t
+    #define __pyx_atomic_incr_relaxed(value) atomic_fetch_add_explicit(value, 1, memory_order_relaxed)
+    #define __pyx_atomic_incr_acq_rel(value) atomic_fetch_add_explicit(value, 1, memory_order_acq_rel)
+    #define __pyx_atomic_decr_acq_rel(value) atomic_fetch_sub_explicit(value, 1, memory_order_acq_rel)
+    #define __pyx_atomic_sub(value, arg) atomic_fetch_sub(value, arg)
+    #define __pyx_atomic_int_cmp_exchange(value, expected, desired) atomic_compare_exchange_strong(value, expected, desired)
+    #define __pyx_atomic_load(value) atomic_load(value)
+    #define __pyx_atomic_store(value, new_value) atomic_store(value, new_value)
+    #define __pyx_atomic_pointer_load_relaxed(value) atomic_load_explicit(value, memory_order_relaxed)
+    #define __pyx_atomic_pointer_load_acquire(value) atomic_load_explicit(value, memory_order_acquire)
+    #define __pyx_atomic_pointer_exchange(value, new_value) atomic_exchange(value, (__pyx_nonatomic_ptr_type)new_value)
+    #if defined(__PYX_DEBUG_ATOMICS) && defined(_MSC_VER)
+        #pragma message ("Using standard C atomics")
+    #elif defined(__PYX_DEBUG_ATOMICS)
+        #warning "Using standard C atomics"
+    #endif
+#elif CYTHON_ATOMICS && (defined(__cplusplus) && (\
+                    (__cplusplus >= 201103L) ||\
+\
+                    (defined(_MSC_VER) && _MSC_VER >= 1700)) &&\
+                    ATOMIC_INT_LOCK_FREE == 2)
+    #undef __pyx_atomic_int_type
+    #define __pyx_atomic_int_type std::atomic_int
+    #define __pyx_atomic_ptr_type std::atomic_uintptr_t
+    #define __pyx_nonatomic_ptr_type uintptr_t
+    #define __pyx_atomic_incr_relaxed(value) std::atomic_fetch_add_explicit(value, 1, std::memory_order_relaxed)
+    #define __pyx_atomic_incr_acq_rel(value) std::atomic_fetch_add_explicit(value, 1, std::memory_order_acq_rel)
+    #define __pyx_atomic_decr_acq_rel(value) std::atomic_fetch_sub_explicit(value, 1, std::memory_order_acq_rel)
+    #define __pyx_atomic_sub(value, arg) std::atomic_fetch_sub(value, arg)
+    #define __pyx_atomic_int_cmp_exchange(value, expected, desired) std::atomic_compare_exchange_strong(value, expected, desired)
+    #define __pyx_atomic_load(value) std::atomic_load(value)
+    #define __pyx_atomic_store(value, new_value) std::atomic_store(value, new_value)
+    #define __pyx_atomic_pointer_load_relaxed(value) std::atomic_load_explicit(value, std::memory_order_relaxed)
+    #define __pyx_atomic_pointer_load_acquire(value) std::atomic_load_explicit(value, std::memory_order_acquire)
+    #define __pyx_atomic_pointer_exchange(value, new_value) std::atomic_exchange(value, (__pyx_nonatomic_ptr_type)new_value)
+    #if defined(__PYX_DEBUG_ATOMICS) && defined(_MSC_VER)
+        #pragma message ("Using standard C++ atomics")
+    #elif defined(__PYX_DEBUG_ATOMICS)
+        #warning "Using standard C++ atomics"
+    #endif
+#elif CYTHON_ATOMICS && (__GNUC__ >= 5 || (__GNUC__ == 4 &&\
+                    (__GNUC_MINOR__ > 1 ||\
+                    (__GNUC_MINOR__ == 1 && __GNUC_PATCHLEVEL__ >= 2))))
+    #define __pyx_atomic_ptr_type void*
+    #define __pyx_atomic_incr_relaxed(value) __sync_fetch_and_add(value, 1)
+    #define __pyx_atomic_incr_acq_rel(value) __sync_fetch_and_add(value, 1)
+    #define __pyx_atomic_decr_acq_rel(value) __sync_fetch_and_sub(value, 1)
+    #define __pyx_atomic_sub(value, arg) __sync_fetch_and_sub(value, arg)
+    static CYTHON_INLINE int __pyx_atomic_int_cmp_exchange(__pyx_atomic_int_type* value, __pyx_nonatomic_int_type* expected, __pyx_nonatomic_int_type desired) {
+        __pyx_nonatomic_int_type old = __sync_val_compare_and_swap(value, *expected, desired);
+        int result = old == *expected;
+        *expected = old;
+        return result;
+    }
+    #define __pyx_atomic_load(value) __sync_fetch_and_add(value, 0)
+    #define __pyx_atomic_store(value, new_value) __sync_lock_test_and_set(value, new_value)
+    #define __pyx_atomic_pointer_load_relaxed(value) __sync_fetch_and_add(value, 0)
+    #define __pyx_atomic_pointer_load_acquire(value) __sync_fetch_and_add(value, 0)
+    #define __pyx_atomic_pointer_exchange(value, new_value) __sync_lock_test_and_set(value, (__pyx_atomic_ptr_type)new_value)
+    #ifdef __PYX_DEBUG_ATOMICS
+        #warning "Using GNU atomics"
+    #endif
+#elif CYTHON_ATOMICS && defined(_MSC_VER)
+    #include <intrin.h>
+    #undef __pyx_atomic_int_type
+    #define __pyx_atomic_int_type long
+    #define __pyx_atomic_ptr_type void*
+    #undef __pyx_nonatomic_int_type
+    #define __pyx_nonatomic_int_type long
+    #pragma intrinsic (_InterlockedExchangeAdd, _InterlockedExchange, _InterlockedCompareExchange, _InterlockedCompareExchangePointer, _InterlockedExchangePointer)
+    #define __pyx_atomic_incr_relaxed(value) _InterlockedExchangeAdd(value, 1)
+    #define __pyx_atomic_incr_acq_rel(value) _InterlockedExchangeAdd(value, 1)
+    #define __pyx_atomic_decr_acq_rel(value) _InterlockedExchangeAdd(value, -1)
+    #define __pyx_atomic_sub(value, arg) _InterlockedExchangeAdd(value, -arg)
+    static CYTHON_INLINE int __pyx_atomic_int_cmp_exchange(__pyx_atomic_int_type* value, __pyx_nonatomic_int_type* expected, __pyx_nonatomic_int_type desired) {
+        __pyx_nonatomic_int_type old = _InterlockedCompareExchange(value, desired, *expected);
+        int result = old == *expected;
+        *expected = old;
+        return result;
+    }
+    #define __pyx_atomic_load(value) _InterlockedExchangeAdd(value, 0)
+    #define __pyx_atomic_store(value, new_value) _InterlockedExchange(value, new_value)
+    #define __pyx_atomic_pointer_load_relaxed(value) *(void * volatile *)value
+    #define __pyx_atomic_pointer_load_acquire(value) _InterlockedCompareExchangePointer(value, 0, 0)
+    #define __pyx_atomic_pointer_exchange(value, new_value) _InterlockedExchangePointer(value, (__pyx_atomic_ptr_type)new_value)
+    #ifdef __PYX_DEBUG_ATOMICS
+        #pragma message ("Using MSVC atomics")
+    #endif
+#else
+    #undef CYTHON_ATOMICS
+    #define CYTHON_ATOMICS 0
+    #ifdef __PYX_DEBUG_ATOMICS
+        #warning "Not using atomics"
+    #endif
+#endif
+#if CYTHON_ATOMICS
+    #define __pyx_add_acquisition_count(memview)\
+             __pyx_atomic_incr_relaxed(__pyx_get_slice_count_pointer(memview))
+    #define __pyx_sub_acquisition_count(memview)\
+            __pyx_atomic_decr_acq_rel(__pyx_get_slice_count_pointer(memview))
+#else
+    #define __pyx_add_acquisition_count(memview)\
+            __pyx_add_acquisition_count_locked(__pyx_get_slice_count_pointer(memview), memview->lock)
+    #define __pyx_sub_acquisition_count(memview)\
+            __pyx_sub_acquisition_count_locked(__pyx_get_slice_count_pointer(memview), memview->lock)
+#endif
+
+/* CriticalSections.proto */
+#if !CYTHON_COMPILING_IN_CPYTHON_FREETHREADING
+#define __Pyx_PyCriticalSection void*
+#define __Pyx_PyCriticalSection2 void*
+#define __Pyx_PyCriticalSection_Begin1(cs, arg) (void)cs
+#define __Pyx_PyCriticalSection_Begin2(cs, arg1, arg2) (void)cs
+#define __Pyx_PyCriticalSection_End1(cs)
+#define __Pyx_PyCriticalSection_End2(cs)
+#else
+#define __Pyx_PyCriticalSection PyCriticalSection
+#define __Pyx_PyCriticalSection2 PyCriticalSection2
+#define __Pyx_PyCriticalSection_Begin1 PyCriticalSection_Begin
+#define __Pyx_PyCriticalSection_Begin2 PyCriticalSection2_Begin
+#define __Pyx_PyCriticalSection_End1 PyCriticalSection_End
+#define __Pyx_PyCriticalSection_End2 PyCriticalSection2_End
+#endif
+#if PY_VERSION_HEX < 0x030d0000 || CYTHON_COMPILING_IN_LIMITED_API
+#define __Pyx_BEGIN_CRITICAL_SECTION(o) {
+#define __Pyx_END_CRITICAL_SECTION() }
+#else
+#define __Pyx_BEGIN_CRITICAL_SECTION Py_BEGIN_CRITICAL_SECTION
+#define __Pyx_END_CRITICAL_SECTION Py_END_CRITICAL_SECTION
+#endif
+
+/* IncludeStructmemberH.proto */
+#include <structmember.h>
+
+/* #### Code section: numeric_typedefs ### */
 
 typedef npy_int8 __pyx_t_5numpy_int8_t;
 
@@ -878,16 +1564,8 @@ typedef npy_float32 __pyx_t_5numpy_float32_t;
 
 typedef npy_float64 __pyx_t_5numpy_float64_t;
 
-typedef npy_long __pyx_t_5numpy_int_t;
-
-typedef npy_longlong __pyx_t_5numpy_long_t;
-
 typedef npy_longlong __pyx_t_5numpy_longlong_t;
 
-typedef npy_ulong __pyx_t_5numpy_uint_t;
-
-typedef npy_ulonglong __pyx_t_5numpy_ulong_t;
-
 typedef npy_ulonglong __pyx_t_5numpy_ulonglong_t;
 
 typedef npy_intp __pyx_t_5numpy_intp_t;
@@ -899,8 +1577,9 @@ typedef npy_double __pyx_t_5numpy_float_t;
 typedef npy_double __pyx_t_5numpy_double_t;
 
 typedef npy_longdouble __pyx_t_5numpy_longdouble_t;
+/* #### Code section: complex_type_declarations ### */
 /* Declarations.proto */
-#if CYTHON_CCOMPLEX
+#if CYTHON_CCOMPLEX && (1) && (!0 || __cplusplus)
   #ifdef __cplusplus
     typedef ::std::complex< float > __pyx_t_float_complex;
   #else
@@ -912,7 +1591,7 @@ typedef npy_longdouble __pyx_t_5numpy_longdouble_t;
 static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float, float);
 
 /* Declarations.proto */
-#if CYTHON_CCOMPLEX
+#if CYTHON_CCOMPLEX && (1) && (!0 || __cplusplus)
   #ifdef __cplusplus
     typedef ::std::complex< double > __pyx_t_double_complex;
   #else
@@ -923,16 +1602,26 @@ static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(floa
 #endif
 static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double, double);
 
+/* Declarations.proto */
+#if CYTHON_CCOMPLEX && (1) && (!0 || __cplusplus)
+  #ifdef __cplusplus
+    typedef ::std::complex< long double > __pyx_t_long_double_complex;
+  #else
+    typedef long double _Complex __pyx_t_long_double_complex;
+  #endif
+#else
+    typedef struct { long double real, imag; } __pyx_t_long_double_complex;
+#endif
+static CYTHON_INLINE __pyx_t_long_double_complex __pyx_t_long_double_complex_from_parts(long double, long double);
 
-/*--- Type declarations ---*/
-
-typedef npy_cfloat __pyx_t_5numpy_cfloat_t;
+/* #### Code section: type_declarations ### */
 
-typedef npy_cdouble __pyx_t_5numpy_cdouble_t;
+/*--- Type declarations ---*/
 
-typedef npy_clongdouble __pyx_t_5numpy_clongdouble_t;
+typedef int (*__pyx_t_5numpy_NpyIter_IterNextFunc)(NpyIter *);
 
-typedef npy_cdouble __pyx_t_5numpy_complex_t;
+typedef void (*__pyx_t_5numpy_NpyIter_GetMultiIndexFunc)(NpyIter *, npy_intp *);
+/* #### Code section: utility_code_proto ### */
 
 /* --- Runtime support code (head) --- */
 /* Refnanny.proto */
@@ -941,42 +1630,48 @@ typedef npy_cdouble __pyx_t_5numpy_complex_t;
 #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 (*INCREF)(void*, PyObject*, Py_ssize_t);
+    void (*DECREF)(void*, PyObject*, Py_ssize_t);
+    void (*GOTREF)(void*, PyObject*, Py_ssize_t);
+    void (*GIVEREF)(void*, PyObject*, Py_ssize_t);
+    void* (*SetupContext)(const char*, Py_ssize_t, 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__);\
+              __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__));\
               PyGILState_Release(__pyx_gilstate_save);\
           } else {\
-              __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\
+              __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__));\
+          }
+  #define __Pyx_RefNannyFinishContextNogil() {\
+              PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\
+              __Pyx_RefNannyFinishContext();\
+              PyGILState_Release(__pyx_gilstate_save);\
+          }
+  #define __Pyx_RefNannyFinishContextNogil() {\
+              PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\
+              __Pyx_RefNannyFinishContext();\
+              PyGILState_Release(__pyx_gilstate_save);\
           }
-#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)
+  #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); else {__Pyx_INCREF(r); }} while(0)
+  #define __Pyx_XDECREF(r)  do { if((r) == NULL); else {__Pyx_DECREF(r); }} while(0)
+  #define __Pyx_XGOTREF(r)  do { if((r) == NULL); else {__Pyx_GOTREF(r); }} while(0)
+  #define __Pyx_XGIVEREF(r) do { if((r) == NULL); else {__Pyx_GIVEREF(r);}} while(0)
 #else
   #define __Pyx_RefNannyDeclarations
   #define __Pyx_RefNannySetupContext(name, acquire_gil)
+  #define __Pyx_RefNannyFinishContextNogil()
   #define __Pyx_RefNannyFinishContext()
   #define __Pyx_INCREF(r) Py_INCREF(r)
   #define __Pyx_DECREF(r) Py_DECREF(r)
@@ -987,6 +1682,10 @@ typedef npy_cdouble __pyx_t_5numpy_complex_t;
   #define __Pyx_XGOTREF(r)
   #define __Pyx_XGIVEREF(r)
 #endif
+#define __Pyx_Py_XDECREF_SET(r, v) do {\
+        PyObject *tmp = (PyObject *) r;\
+        r = v; Py_XDECREF(tmp);\
+    } while (0)
 #define __Pyx_XDECREF_SET(r, v) do {\
         PyObject *tmp = (PyObject *) r;\
         r = v; __Pyx_XDECREF(tmp);\
@@ -998,6 +1697,57 @@ typedef npy_cdouble __pyx_t_5numpy_complex_t;
 #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)
 
+/* 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
+
+/* PyThreadStateGet.proto */
+#if CYTHON_FAST_THREAD_STATE
+#define __Pyx_PyThreadState_declare  PyThreadState *__pyx_tstate;
+#define __Pyx_PyThreadState_assign  __pyx_tstate = __Pyx_PyThreadState_Current;
+#if PY_VERSION_HEX >= 0x030C00A6
+#define __Pyx_PyErr_Occurred()  (__pyx_tstate->current_exception != NULL)
+#define __Pyx_PyErr_CurrentExceptionType()  (__pyx_tstate->current_exception ? (PyObject*) Py_TYPE(__pyx_tstate->current_exception) : (PyObject*) NULL)
+#else
+#define __Pyx_PyErr_Occurred()  (__pyx_tstate->curexc_type != NULL)
+#define __Pyx_PyErr_CurrentExceptionType()  (__pyx_tstate->curexc_type)
+#endif
+#else
+#define __Pyx_PyThreadState_declare
+#define __Pyx_PyThreadState_assign
+#define __Pyx_PyErr_Occurred()  (PyErr_Occurred() != NULL)
+#define __Pyx_PyErr_CurrentExceptionType()  PyErr_Occurred()
+#endif
+
+/* PyErrFetchRestore.proto */
+#if CYTHON_FAST_THREAD_STATE
+#define __Pyx_PyErr_Clear() __Pyx_ErrRestore(NULL, NULL, NULL)
+#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);
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A6
+#define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL))
+#else
+#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc)
+#endif
+#else
+#define __Pyx_PyErr_Clear() PyErr_Clear()
+#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc)
+#define __Pyx_ErrRestoreWithState(type, value, tb)  PyErr_Restore(type, value, tb)
+#define __Pyx_ErrFetchWithState(type, value, tb)  PyErr_Fetch(type, value, tb)
+#define __Pyx_ErrRestoreInState(tstate, type, value, tb)  PyErr_Restore(type, value, tb)
+#define __Pyx_ErrFetchInState(tstate, 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
+
 /* PyObjectGetAttrStr.proto */
 #if CYTHON_USE_TYPE_SLOTS
 static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name);
@@ -1005,30 +1755,54 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject
 #define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n)
 #endif
 
+/* PyObjectGetAttrStrNoError.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name);
+
 /* GetBuiltinName.proto */
 static PyObject *__Pyx_GetBuiltinName(PyObject *name);
 
-/* PyCFunctionFastCall.proto */
-#if CYTHON_FAST_PYCCALL
-static CYTHON_INLINE PyObject *__Pyx_PyCFunction_FastCall(PyObject *func, PyObject **args, Py_ssize_t nargs);
+/* GetTopmostException.proto */
+#if CYTHON_USE_EXC_INFO_STACK && CYTHON_FAST_THREAD_STATE
+static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate);
+#endif
+
+/* 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
+
+/* 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
-#define __Pyx_PyCFunction_FastCall(func, args, nargs)  (assert(0), NULL)
+static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb);
 #endif
 
 /* PyFunctionFastCall.proto */
 #if CYTHON_FAST_PYCALL
+#if !CYTHON_VECTORCALL
 #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)
+static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject *const *args, Py_ssize_t nargs, PyObject *kwargs);
 #endif
 #define __Pyx_BUILD_ASSERT_EXPR(cond)\
     (sizeof(char [1 - 2*!(cond)]) - 1)
 #ifndef Py_MEMBER_SIZE
 #define Py_MEMBER_SIZE(type, member) sizeof(((type *)0)->member)
 #endif
+#if !CYTHON_VECTORCALL
+#if PY_VERSION_HEX >= 0x03080000
+  #include "frameobject.h"
+  #define __Pxy_PyFrame_Initialize_Offsets()
+  #define __Pyx_PyFrame_GetLocalsplus(frame)  ((frame)->f_localsplus)
+#else
   static size_t __pyx_pyframe_localsplus_offset = 0;
   #include "frameobject.h"
   #define __Pxy_PyFrame_Initialize_Offsets()\
@@ -1037,6 +1811,8 @@ static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args,
   #define __Pyx_PyFrame_GetLocalsplus(frame)\
     (assert(__pyx_pyframe_localsplus_offset), (PyObject **)(((char *)(frame)) + __pyx_pyframe_localsplus_offset))
 #endif
+#endif
+#endif
 
 /* PyObjectCall.proto */
 #if CYTHON_COMPILING_IN_CPYTHON
@@ -1050,80 +1826,191 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg
 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);
+/* PyObjectFastCall.proto */
+#define __Pyx_PyObject_FastCall(func, args, nargs)  __Pyx_PyObject_FastCallDict(func, args, (size_t)(nargs), NULL)
+static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject * const*args, size_t nargs, PyObject *kwargs);
 
-/* PyThreadStateGet.proto */
-#if CYTHON_FAST_THREAD_STATE
-#define __Pyx_PyThreadState_declare  PyThreadState *__pyx_tstate;
-#define __Pyx_PyThreadState_assign  __pyx_tstate = __Pyx_PyThreadState_Current;
-#define __Pyx_PyErr_Occurred()  __pyx_tstate->curexc_type
-#else
-#define __Pyx_PyThreadState_declare
-#define __Pyx_PyThreadState_assign
-#define __Pyx_PyErr_Occurred()  PyErr_Occurred()
-#endif
+/* RaiseException.proto */
+static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause);
 
-/* PyErrFetchRestore.proto */
-#if CYTHON_FAST_THREAD_STATE
-#define __Pyx_PyErr_Clear() __Pyx_ErrRestore(NULL, NULL, NULL)
-#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);
+/* PyUnicode_Unicode.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyUnicode_Unicode(PyObject *obj);
+
+/* PyObjectFormatAndDecref.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_FormatSimpleAndDecref(PyObject* s, PyObject* f);
+static CYTHON_INLINE PyObject* __Pyx_PyObject_FormatAndDecref(PyObject* s, PyObject* f);
+
+/* IncludeStringH.proto */
+#include <string.h>
+
+/* JoinPyUnicode.proto */
+static PyObject* __Pyx_PyUnicode_Join(PyObject** values, Py_ssize_t value_count, Py_ssize_t result_ulength,
+                                      Py_UCS4 max_char);
+
+/* TupleAndListFromArray.proto */
 #if CYTHON_COMPILING_IN_CPYTHON
-#define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL))
-#else
-#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc)
+static CYTHON_INLINE PyObject* __Pyx_PyList_FromArray(PyObject *const *src, Py_ssize_t n);
 #endif
-#else
-#define __Pyx_PyErr_Clear() PyErr_Clear()
-#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc)
-#define __Pyx_ErrRestoreWithState(type, value, tb)  PyErr_Restore(type, value, tb)
-#define __Pyx_ErrFetchWithState(type, value, tb)  PyErr_Fetch(type, value, tb)
-#define __Pyx_ErrRestoreInState(tstate, type, value, tb)  PyErr_Restore(type, value, tb)
-#define __Pyx_ErrFetchInState(tstate, 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)
+#if CYTHON_COMPILING_IN_CPYTHON || CYTHON_METH_FASTCALL
+static CYTHON_INLINE PyObject* __Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n);
 #endif
 
-/* RaiseException.proto */
-static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause);
+/* BytesEquals.proto */
+static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals);
 
-/* 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);
+/* UnicodeEquals.proto */
+static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals);
+
+/* fastcall.proto */
+#if CYTHON_AVOID_BORROWED_REFS
+    #define __Pyx_ArgRef_VARARGS(args, i) __Pyx_PySequence_ITEM(args, i)
+#elif CYTHON_ASSUME_SAFE_MACROS
+    #define __Pyx_ArgRef_VARARGS(args, i) __Pyx_NewRef(__Pyx_PyTuple_GET_ITEM(args, i))
+#else
+    #define __Pyx_ArgRef_VARARGS(args, i) __Pyx_XNewRef(PyTuple_GetItem(args, i))
+#endif
+#define __Pyx_NumKwargs_VARARGS(kwds) PyDict_Size(kwds)
+#define __Pyx_KwValues_VARARGS(args, nargs) NULL
+#define __Pyx_GetKwValue_VARARGS(kw, kwvalues, s) __Pyx_PyDict_GetItemStrWithError(kw, s)
+#define __Pyx_KwargsAsDict_VARARGS(kw, kwvalues) PyDict_Copy(kw)
+#if CYTHON_METH_FASTCALL
+    #define __Pyx_ArgRef_FASTCALL(args, i) __Pyx_NewRef(args[i])
+    #define __Pyx_NumKwargs_FASTCALL(kwds) __Pyx_PyTuple_GET_SIZE(kwds)
+    #define __Pyx_KwValues_FASTCALL(args, nargs) ((args) + (nargs))
+    static CYTHON_INLINE PyObject * __Pyx_GetKwValue_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues, PyObject *s);
+  #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000 || CYTHON_COMPILING_IN_LIMITED_API
+    CYTHON_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues);
+  #else
+    #define __Pyx_KwargsAsDict_FASTCALL(kw, kwvalues) _PyStack_AsDict(kwvalues, kw)
+  #endif
+#else
+    #define __Pyx_ArgRef_FASTCALL __Pyx_ArgRef_VARARGS
+    #define __Pyx_NumKwargs_FASTCALL __Pyx_NumKwargs_VARARGS
+    #define __Pyx_KwValues_FASTCALL __Pyx_KwValues_VARARGS
+    #define __Pyx_GetKwValue_FASTCALL __Pyx_GetKwValue_VARARGS
+    #define __Pyx_KwargsAsDict_FASTCALL __Pyx_KwargsAsDict_VARARGS
+#endif
+#define __Pyx_ArgsSlice_VARARGS(args, start, stop) PyTuple_GetSlice(args, start, stop)
+#if CYTHON_METH_FASTCALL || (CYTHON_COMPILING_IN_CPYTHON && CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS)
+#define __Pyx_ArgsSlice_FASTCALL(args, start, stop) __Pyx_PyTuple_FromArray(args + start, stop - start)
+#else
+#define __Pyx_ArgsSlice_FASTCALL(args, start, stop) PyTuple_GetSlice(args, start, stop)
+#endif
 
 /* 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);
+static CYTHON_INLINE int __Pyx_ParseKeywords(
+    PyObject *kwds, PyObject *const *kwvalues, PyObject ** const argnames[],
+    PyObject *kwds2, PyObject *values[],
+    Py_ssize_t num_pos_args, Py_ssize_t num_kwargs,
+    const char* function_name,
+    int ignore_unknown_kwargs
+);
+
+/* CallCFunction.proto */
+#define __Pyx_CallCFunction(cfunc, self, args)\
+    ((PyCFunction)(void(*)(void))(cfunc)->func)(self, args)
+#define __Pyx_CallCFunctionWithKeywords(cfunc, self, args, kwargs)\
+    ((PyCFunctionWithKeywords)(void(*)(void))(cfunc)->func)(self, args, kwargs)
+#define __Pyx_CallCFunctionFast(cfunc, self, args, nargs)\
+    ((__Pyx_PyCFunctionFast)(void(*)(void))(PyCFunction)(cfunc)->func)(self, args, nargs)
+#define __Pyx_CallCFunctionFastWithKeywords(cfunc, self, args, nargs, kwnames)\
+    ((__Pyx_PyCFunctionFastWithKeywords)(void(*)(void))(PyCFunction)(cfunc)->func)(self, args, nargs, kwnames)
 
-/* ArgTypeTest.proto */
-#define __Pyx_ArgTypeTest(obj, type, none_allowed, name, exact)\
-    ((likely((Py_TYPE(obj) == type) | (none_allowed && (obj == Py_None)))) ? 1 :\
-        __Pyx__ArgTypeTest(obj, type, name, exact))
-static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact);
-
-/* GetModuleGlobalName.proto */
-#if CYTHON_USE_DICT_VERSIONS
-#define __Pyx_GetModuleGlobalName(var, name)  {\
-    static PY_UINT64_T __pyx_dict_version = 0;\
+/* UnpackUnboundCMethod.proto */
+typedef struct {
+    PyObject *type;
+    PyObject **method_name;
+#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING && CYTHON_ATOMICS
+    __pyx_atomic_int_type initialized;
+#endif
+    PyCFunction func;
+    PyObject *method;
+    int flag;
+} __Pyx_CachedCFunction;
+#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING
+static CYTHON_INLINE int __Pyx_CachedCFunction_GetAndSetInitializing(__Pyx_CachedCFunction *cfunc) {
+#if !CYTHON_ATOMICS
+    return 1;
+#else
+    __pyx_nonatomic_int_type expected = 0;
+    if (__pyx_atomic_int_cmp_exchange(&cfunc->initialized, &expected, 1)) {
+        return 0;
+    }
+    return expected;
+#endif
+}
+static CYTHON_INLINE void __Pyx_CachedCFunction_SetFinishedInitializing(__Pyx_CachedCFunction *cfunc) {
+#if CYTHON_ATOMICS
+    __pyx_atomic_store(&cfunc->initialized, 2);
+#endif
+}
+#else
+#define __Pyx_CachedCFunction_GetAndSetInitializing(cfunc) 2
+#define __Pyx_CachedCFunction_SetFinishedInitializing(cfunc)
+#endif
+
+/* CallUnboundCMethod2.proto */
+CYTHON_UNUSED
+static PyObject* __Pyx__CallUnboundCMethod2(__Pyx_CachedCFunction* cfunc, PyObject* self, PyObject* arg1, PyObject* arg2);
+#if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE PyObject *__Pyx_CallUnboundCMethod2(__Pyx_CachedCFunction *cfunc, PyObject *self, PyObject *arg1, PyObject *arg2);
+#else
+#define __Pyx_CallUnboundCMethod2(cfunc, self, arg1, arg2)  __Pyx__CallUnboundCMethod2(cfunc, self, arg1, arg2)
+#endif
+
+/* 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);
+
+/* ArgTypeTest.proto */
+#define __Pyx_ArgTypeTest(obj, type, none_allowed, name, exact)\
+    ((likely(__Pyx_IS_TYPE(obj, type) | (none_allowed && (obj == Py_None)))) ? 1 :\
+        __Pyx__ArgTypeTest(obj, type, name, exact))
+static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact);
+
+/* PyDictVersioning.proto */
+#if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS
+#define __PYX_DICT_VERSION_INIT  ((PY_UINT64_T) -1)
+#define __PYX_GET_DICT_VERSION(dict)  (((PyDictObject*)(dict))->ma_version_tag)
+#define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var)\
+    (version_var) = __PYX_GET_DICT_VERSION(dict);\
+    (cache_var) = (value);
+#define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) {\
+    static PY_UINT64_T __pyx_dict_version = 0;\
+    static PyObject *__pyx_dict_cached_value = NULL;\
+    if (likely(__PYX_GET_DICT_VERSION(DICT) == __pyx_dict_version)) {\
+        (VAR) = __pyx_dict_cached_value;\
+    } else {\
+        (VAR) = __pyx_dict_cached_value = (LOOKUP);\
+        __pyx_dict_version = __PYX_GET_DICT_VERSION(DICT);\
+    }\
+}
+static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj);
+static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj);
+static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version);
+#else
+#define __PYX_GET_DICT_VERSION(dict)  (0)
+#define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var)
+#define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP)  (VAR) = (LOOKUP);
+#endif
+
+/* GetModuleGlobalName.proto */
+#if CYTHON_USE_DICT_VERSIONS
+#define __Pyx_GetModuleGlobalName(var, name)  do {\
+    static PY_UINT64_T __pyx_dict_version = 0;\
     static PyObject *__pyx_dict_cached_value = NULL;\
-    (var) = (likely(__pyx_dict_version == __PYX_GET_DICT_VERSION(__pyx_d))) ?\
+    (var) = (likely(__pyx_dict_version == __PYX_GET_DICT_VERSION(__pyx_mstate_global->__pyx_d))) ?\
         (likely(__pyx_dict_cached_value) ? __Pyx_NewRef(__pyx_dict_cached_value) : __Pyx_GetBuiltinName(name)) :\
         __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\
-}
-#define __Pyx_GetModuleGlobalNameUncached(var, name)  {\
+} while(0)
+#define __Pyx_GetModuleGlobalNameUncached(var, name)  do {\
     PY_UINT64_T __pyx_dict_version;\
     PyObject *__pyx_dict_cached_value;\
     (var) = __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\
-}
+} while(0)
 static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value);
 #else
 #define __Pyx_GetModuleGlobalName(var, name)  (var) = __Pyx__GetModuleGlobalName(name)
@@ -1131,28 +2018,35 @@ static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_ve
 static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name);
 #endif
 
+/* PyObjectDelAttr.proto */
+#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030d0000
+#define __Pyx_PyObject_DelAttr(o, n) PyObject_SetAttr(o, n, NULL)
+#else
+#define __Pyx_PyObject_DelAttr(o, n) PyObject_DelAttr(o, n)
+#endif
+
 /* PyObjectSetAttrStr.proto */
 #if CYTHON_USE_TYPE_SLOTS
 #define __Pyx_PyObject_DelAttrStr(o,n) __Pyx_PyObject_SetAttrStr(o, n, NULL)
 static CYTHON_INLINE int __Pyx_PyObject_SetAttrStr(PyObject* obj, PyObject* attr_name, PyObject* value);
 #else
-#define __Pyx_PyObject_DelAttrStr(o,n)   PyObject_DelAttr(o,n)
+#define __Pyx_PyObject_DelAttrStr(o,n)   __Pyx_PyObject_DelAttr(o,n)
 #define __Pyx_PyObject_SetAttrStr(o,n,v) PyObject_SetAttr(o,n,v)
 #endif
 
 /* GetItemInt.proto */
-#define __Pyx_GetItemInt(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\
+#define __Pyx_GetItemInt(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck, has_gil)\
     (__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)\
+#define __Pyx_GetItemInt_List(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck, has_gil)\
     (__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)\
+#define __Pyx_GetItemInt_Tuple(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck, has_gil)\
     (__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))
@@ -1162,25 +2056,32 @@ static 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);
 
+/* PyObjectCallOneArg.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg);
+
 /* ObjectGetItem.proto */
 #if CYTHON_USE_TYPE_SLOTS
-static CYTHON_INLINE PyObject *__Pyx_PyObject_GetItem(PyObject *obj, PyObject* key);
+static CYTHON_INLINE PyObject *__Pyx_PyObject_GetItem(PyObject *obj, PyObject *key);
 #else
 #define __Pyx_PyObject_GetItem(obj, key)  PyObject_GetItem(obj, key)
 #endif
 
-/* PyObjectCall2Args.proto */
-static CYTHON_UNUSED PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2);
+/* PyObjectFastCallMethod.proto */
+#if CYTHON_VECTORCALL && PY_VERSION_HEX >= 0x03090000
+#define __Pyx_PyObject_FastCallMethod(name, args, nargsf) PyObject_VectorcallMethod(name, args, nargsf, NULL)
+#else
+static PyObject *__Pyx_PyObject_FastCallMethod(PyObject *name, PyObject *const *args, size_t nargsf);
+#endif
 
-/* PyObjectCallNoArg.proto */
-#if CYTHON_COMPILING_IN_CPYTHON
-static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func);
+/* HasAttr.proto */
+#if __PYX_LIMITED_VERSION_HEX >= 0x030d0000
+#define __Pyx_HasAttr(o, n)  PyObject_HasAttrWithError(o, n)
 #else
-#define __Pyx_PyObject_CallNoArg(func) __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL)
+static CYTHON_INLINE int __Pyx_HasAttr(PyObject *, PyObject *);
 #endif
 
 /* DictGetItem.proto */
-#if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY
+#if !CYTHON_COMPILING_IN_PYPY
 static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key);
 #define __Pyx_PyObject_Dict_GetItem(obj, name)\
     (likely(PyDict_CheckExact(obj)) ?\
@@ -1215,8 +2116,12 @@ static CYTHON_INLINE int __Pyx_PyList_Append(PyObject* list, PyObject* x) {
     Py_ssize_t len = Py_SIZE(list);
     if (likely(L->allocated > len) & likely(len > (L->allocated >> 1))) {
         Py_INCREF(x);
+        #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000
+        L->ob_item[len] = x;
+        #else
         PyList_SET_ITEM(list, len, x);
-        Py_SIZE(list) = len+1;
+        #endif
+        __Pyx_SET_SIZE(list, len + 1);
         return 0;
     }
     return PyList_Append(list, x);
@@ -1225,23 +2130,8 @@ static CYTHON_INLINE int __Pyx_PyList_Append(PyObject* list, PyObject* x) {
 #define __Pyx_PyList_Append(L,x) PyList_Append(L,x)
 #endif
 
-/* StringJoin.proto */
-#if PY_MAJOR_VERSION < 3
-#define __Pyx_PyString_Join __Pyx_PyBytes_Join
-#define __Pyx_PyBaseString_Join(s, v) (PyUnicode_CheckExact(s) ? PyUnicode_Join(s, v) : __Pyx_PyBytes_Join(s, v))
-#else
-#define __Pyx_PyString_Join PyUnicode_Join
-#define __Pyx_PyBaseString_Join PyUnicode_Join
-#endif
-#if CYTHON_COMPILING_IN_CPYTHON
-    #if PY_MAJOR_VERSION < 3
-    #define __Pyx_PyBytes_Join _PyString_Join
-    #else
-    #define __Pyx_PyBytes_Join _PyBytes_Join
-    #endif
-#else
-static CYTHON_INLINE PyObject* __Pyx_PyBytes_Join(PyObject* sep, PyObject* values);
-#endif
+/* PyObjectCallNoArg.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func);
 
 /* PyObjectGetMethod.proto */
 static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method);
@@ -1256,12 +2146,8 @@ static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void);
 static void __Pyx_UnpackTupleError(PyObject *, Py_ssize_t index);
 
 /* UnpackTuple2.proto */
-#define __Pyx_unpack_tuple2(tuple, value1, value2, is_tuple, has_known_size, decref_tuple)\
-    (likely(is_tuple || PyTuple_Check(tuple)) ?\
-        (likely(has_known_size || PyTuple_GET_SIZE(tuple) == 2) ?\
-            __Pyx_unpack_tuple2_exact(tuple, value1, value2, decref_tuple) :\
-            (__Pyx_UnpackTupleError(tuple, 2), -1)) :\
-        __Pyx_unpack_tuple2_generic(tuple, value1, value2, has_known_size, decref_tuple))
+static CYTHON_INLINE int __Pyx_unpack_tuple2(
+    PyObject* tuple, PyObject** value1, PyObject** value2, int is_tuple, int has_known_size, int decref_tuple);
 static CYTHON_INLINE int __Pyx_unpack_tuple2_exact(
     PyObject* tuple, PyObject** value1, PyObject** value2, int decref_tuple);
 static int __Pyx_unpack_tuple2_generic(
@@ -1273,14 +2159,32 @@ static CYTHON_INLINE PyObject* __Pyx_dict_iterator(PyObject* dict, int is_dict,
 static CYTHON_INLINE int __Pyx_dict_iter_next(PyObject* dict_or_iter, Py_ssize_t orig_length, Py_ssize_t* ppos,
                                               PyObject** pkey, PyObject** pvalue, PyObject** pitem, int is_dict);
 
-/* PyIntBinop.proto */
+/* PyLongBinop.proto */
 #if !CYTHON_COMPILING_IN_PYPY
-static PyObject* __Pyx_PyInt_AddObjC(PyObject *op1, PyObject *op2, long intval, int inplace);
+static CYTHON_INLINE PyObject* __Pyx_PyLong_AddObjC(PyObject *op1, PyObject *op2, long intval, int inplace, int zerodivision_check);
 #else
-#define __Pyx_PyInt_AddObjC(op1, op2, intval, inplace)\
+#define __Pyx_PyLong_AddObjC(op1, op2, intval, inplace, zerodivision_check)\
     (inplace ? PyNumber_InPlaceAdd(op1, op2) : PyNumber_Add(op1, op2))
 #endif
 
+/* PyObjectVectorCallKwBuilder.proto */
+CYTHON_UNUSED static int __Pyx_VectorcallBuilder_AddArg_Check(PyObject *key, PyObject *value, PyObject *builder, PyObject **args, int n);
+#if CYTHON_VECTORCALL
+#if PY_VERSION_HEX >= 0x03090000
+#define __Pyx_Object_Vectorcall_CallFromBuilder PyObject_Vectorcall
+#else
+#define __Pyx_Object_Vectorcall_CallFromBuilder _PyObject_Vectorcall
+#endif
+#define __Pyx_MakeVectorcallBuilderKwds(n) PyTuple_New(n)
+static int __Pyx_VectorcallBuilder_AddArg(PyObject *key, PyObject *value, PyObject *builder, PyObject **args, int n);
+static int __Pyx_VectorcallBuilder_AddArgStr(const char *key, PyObject *value, PyObject *builder, PyObject **args, int n);
+#else
+#define __Pyx_Object_Vectorcall_CallFromBuilder __Pyx_PyObject_FastCallDict
+#define __Pyx_MakeVectorcallBuilderKwds(n) __Pyx_PyDict_NewPresized(n)
+#define __Pyx_VectorcallBuilder_AddArg(key, value, builder, args, n) PyDict_SetItem(builder, key, value)
+#define __Pyx_VectorcallBuilder_AddArgStr(key, value, builder, args, n) PyDict_SetItemString(builder, key, value)
+#endif
+
 /* ListCompAppend.proto */
 #if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS
 static CYTHON_INLINE int __Pyx_ListComp_Append(PyObject* list, PyObject* x) {
@@ -1288,8 +2192,12 @@ static CYTHON_INLINE int __Pyx_ListComp_Append(PyObject* list, PyObject* x) {
     Py_ssize_t len = Py_SIZE(list);
     if (likely(L->allocated > len)) {
         Py_INCREF(x);
+        #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000
+        L->ob_item[len] = x;
+        #else
         PyList_SET_ITEM(list, len, x);
-        Py_SIZE(list) = len+1;
+        #endif
+        __Pyx_SET_SIZE(list, len + 1);
         return 0;
     }
     return PyList_Append(list, x);
@@ -1298,37 +2206,24 @@ static CYTHON_INLINE int __Pyx_ListComp_Append(PyObject* list, PyObject* x) {
 #define __Pyx_ListComp_Append(L,x) PyList_Append(L,x)
 #endif
 
-/* GetTopmostException.proto */
-#if CYTHON_USE_EXC_INFO_STACK
-static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate);
-#endif
+/* BuildPyUnicode.proto */
+static PyObject* __Pyx_PyUnicode_BuildFromAscii(Py_ssize_t ulength, const char* chars, int clength,
+                                                int prepend_sign, char padding_char);
 
-/* 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
+/* COrdinalToPyUnicode.proto */
+static CYTHON_INLINE int __Pyx_CheckUnicodeValue(int value);
+static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromOrdinal_Padded(int value, Py_ssize_t width, char padding_char);
 
-/* 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)
+/* GCCDiagnostics.proto */
+#if !defined(__INTEL_COMPILER) && defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
+#define __Pyx_HAS_GCC_DIAGNOSTIC
 #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
+/* IncludeStdlibH.proto */
+#include <stdlib.h>
+
+/* CIntToPyUnicode.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyUnicode_From_Py_ssize_t(Py_ssize_t value, Py_ssize_t width, char padding_char, char format_char);
 
 /* SliceTupleAndList.proto */
 #if CYTHON_COMPILING_IN_CPYTHON
@@ -1340,50 +2235,23 @@ static CYTHON_INLINE PyObject* __Pyx_PyTuple_GetSlice(PyObject* src, Py_ssize_t
 #endif
 
 /* PyObject_Unicode.proto */
-#if PY_MAJOR_VERSION >= 3
 #define __Pyx_PyObject_Unicode(obj)\
     (likely(PyUnicode_CheckExact(obj)) ? __Pyx_NewRef(obj) : PyObject_Str(obj))
-#else
-#define __Pyx_PyObject_Unicode(obj)\
-    (likely(PyUnicode_CheckExact(obj)) ? __Pyx_NewRef(obj) : PyObject_Unicode(obj))
-#endif
 
 /* py_dict_keys.proto */
 static CYTHON_INLINE PyObject* __Pyx_PyDict_Keys(PyObject* d);
 
-/* UnpackUnboundCMethod.proto */
-typedef struct {
-    PyObject *type;
-    PyObject **method_name;
-    PyCFunction func;
-    PyObject *method;
-    int flag;
-} __Pyx_CachedCFunction;
-
 /* CallUnboundCMethod0.proto */
+CYTHON_UNUSED
 static PyObject* __Pyx__CallUnboundCMethod0(__Pyx_CachedCFunction* cfunc, PyObject* self);
 #if CYTHON_COMPILING_IN_CPYTHON
-#define __Pyx_CallUnboundCMethod0(cfunc, self)\
-    (likely((cfunc)->func) ?\
-        (likely((cfunc)->flag == METH_NOARGS) ?  (*((cfunc)->func))(self, NULL) :\
-         (PY_VERSION_HEX >= 0x030600B1 && likely((cfunc)->flag == METH_FASTCALL) ?\
-            (PY_VERSION_HEX >= 0x030700A0 ?\
-                (*(__Pyx_PyCFunctionFast)(void*)(PyCFunction)(cfunc)->func)(self, &__pyx_empty_tuple, 0) :\
-                (*(__Pyx_PyCFunctionFastWithKeywords)(void*)(PyCFunction)(cfunc)->func)(self, &__pyx_empty_tuple, 0, NULL)) :\
-          (PY_VERSION_HEX >= 0x030700A0 && (cfunc)->flag == (METH_FASTCALL | METH_KEYWORDS) ?\
-            (*(__Pyx_PyCFunctionFastWithKeywords)(void*)(PyCFunction)(cfunc)->func)(self, &__pyx_empty_tuple, 0, NULL) :\
-            (likely((cfunc)->flag == (METH_VARARGS | METH_KEYWORDS)) ?  ((*(PyCFunctionWithKeywords)(void*)(PyCFunction)(cfunc)->func)(self, __pyx_empty_tuple, NULL)) :\
-               ((cfunc)->flag == METH_VARARGS ?  (*((cfunc)->func))(self, __pyx_empty_tuple) :\
-               __Pyx__CallUnboundCMethod0(cfunc, self)))))) :\
-        __Pyx__CallUnboundCMethod0(cfunc, self))
+static CYTHON_INLINE PyObject* __Pyx_CallUnboundCMethod0(__Pyx_CachedCFunction* cfunc, PyObject* self);
 #else
 #define __Pyx_CallUnboundCMethod0(cfunc, self)  __Pyx__CallUnboundCMethod0(cfunc, self)
 #endif
 
-/* PyNumberPow2.proto */
-#define __Pyx_PyNumber_InPlacePowerOf2(a, b, c) __Pyx__PyNumber_PowerOf2(a, b, c, 1)
-#define __Pyx_PyNumber_PowerOf2(a, b, c) __Pyx__PyNumber_PowerOf2(a, b, c, 0)
-static PyObject* __Pyx__PyNumber_PowerOf2(PyObject *two, PyObject *exp, PyObject *none, int inplace);
+/* RaiseUnexpectedTypeError.proto */
+static int __Pyx_RaiseUnexpectedTypeError(const char *expected, PyObject *obj);
 
 /* SliceObject.proto */
 static CYTHON_INLINE PyObject* __Pyx_PyObject_GetSlice(
@@ -1391,35 +2259,8 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_GetSlice(
         PyObject** py_start, PyObject** py_stop, PyObject** py_slice,
         int has_cstart, int has_cstop, int wraparound);
 
-/* PyIntCompare.proto */
-static CYTHON_INLINE PyObject* __Pyx_PyInt_EqObjC(PyObject *op1, PyObject *op2, long intval, long inplace);
-
-/* PyIntBinop.proto */
-#if !CYTHON_COMPILING_IN_PYPY
-static PyObject* __Pyx_PyInt_RemainderObjC(PyObject *op1, PyObject *op2, long intval, int inplace);
-#else
-#define __Pyx_PyInt_RemainderObjC(op1, op2, intval, inplace)\
-    (inplace ? PyNumber_InPlaceRemainder(op1, op2) : PyNumber_Remainder(op1, op2))
-#endif
-
-/* IncludeStringH.proto */
-#include <string.h>
-
-/* BytesEquals.proto */
-static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals);
-
-/* UnicodeEquals.proto */
-static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals);
-
-/* StrEquals.proto */
-#if PY_MAJOR_VERSION >= 3
-#define __Pyx_PyString_Equals __Pyx_PyUnicode_Equals
-#else
-#define __Pyx_PyString_Equals __Pyx_PyBytes_Equals
-#endif
-
 /* SetItemInt.proto */
-#define __Pyx_SetItemInt(o, i, v, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\
+#define __Pyx_SetItemInt(o, i, v, type, is_signed, to_py_func, is_list, wraparound, boundscheck, has_gil)\
     (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\
     __Pyx_SetItemInt_Fast(o, (Py_ssize_t)i, v, is_list, wraparound, boundscheck) :\
     (is_list ? (PyErr_SetString(PyExc_IndexError, "list assignment index out of range"), -1) :\
@@ -1428,58 +2269,100 @@ static int __Pyx_SetItemInt_Generic(PyObject *o, PyObject *j, PyObject *v);
 static CYTHON_INLINE int __Pyx_SetItemInt_Fast(PyObject *o, Py_ssize_t i, PyObject *v,
                                                int is_list, int wraparound, int boundscheck);
 
-/* WriteUnraisableException.proto */
-static void __Pyx_WriteUnraisable(const char *name, int clineno,
-                                  int lineno, const char *filename,
-                                  int full_traceback, int nogil);
-
-/* ExtTypeTest.proto */
-static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type);
-
 /* TypeImport.proto */
-#ifndef __PYX_HAVE_RT_ImportType_proto
-#define __PYX_HAVE_RT_ImportType_proto
-enum __Pyx_ImportType_CheckSize {
-   __Pyx_ImportType_CheckSize_Error = 0,
-   __Pyx_ImportType_CheckSize_Warn = 1,
-   __Pyx_ImportType_CheckSize_Ignore = 2
+#ifndef __PYX_HAVE_RT_ImportType_proto_3_1_5
+#define __PYX_HAVE_RT_ImportType_proto_3_1_5
+#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L
+#include <stdalign.h>
+#endif
+#if (defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L) || __cplusplus >= 201103L
+#define __PYX_GET_STRUCT_ALIGNMENT_3_1_5(s) alignof(s)
+#else
+#define __PYX_GET_STRUCT_ALIGNMENT_3_1_5(s) sizeof(void*)
+#endif
+enum __Pyx_ImportType_CheckSize_3_1_5 {
+   __Pyx_ImportType_CheckSize_Error_3_1_5 = 0,
+   __Pyx_ImportType_CheckSize_Warn_3_1_5 = 1,
+   __Pyx_ImportType_CheckSize_Ignore_3_1_5 = 2
 };
-static PyTypeObject *__Pyx_ImportType(PyObject* module, const char *module_name, const char *class_name, size_t size, enum __Pyx_ImportType_CheckSize check_size);
+static PyTypeObject *__Pyx_ImportType_3_1_5(PyObject* module, const char *module_name, const char *class_name, size_t size, size_t alignment, enum __Pyx_ImportType_CheckSize_3_1_5 check_size);
 #endif
 
-/* CalculateMetaclass.proto */
-static PyObject *__Pyx_CalculateMetaclass(PyTypeObject *metaclass, PyObject *bases);
+/* LimitedApiGetTypeDict.proto */
+#if CYTHON_COMPILING_IN_LIMITED_API
+static PyObject *__Pyx_GetTypeDict(PyTypeObject *tp);
+#endif
 
-/* SetNameInClass.proto */
-#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1
-#define __Pyx_SetNameInClass(ns, name, value)\
-    (likely(PyDict_CheckExact(ns)) ? _PyDict_SetItem_KnownHash(ns, name, value, ((PyASCIIObject *) name)->hash) : PyObject_SetItem(ns, name, value))
-#elif CYTHON_COMPILING_IN_CPYTHON
-#define __Pyx_SetNameInClass(ns, name, value)\
-    (likely(PyDict_CheckExact(ns)) ? PyDict_SetItem(ns, name, value) : PyObject_SetItem(ns, name, value))
+/* SetItemOnTypeDict.proto */
+static int __Pyx__SetItemOnTypeDict(PyTypeObject *tp, PyObject *k, PyObject *v);
+#define __Pyx_SetItemOnTypeDict(tp, k, v) __Pyx__SetItemOnTypeDict((PyTypeObject*)tp, k, v)
+
+/* FixUpExtensionType.proto */
+static CYTHON_INLINE int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject *type);
+
+/* FetchSharedCythonModule.proto */
+static PyObject *__Pyx_FetchSharedCythonABIModule(void);
+
+/* dict_setdefault.proto */
+static CYTHON_INLINE PyObject *__Pyx_PyDict_SetDefault(PyObject *d, PyObject *key, PyObject *default_value, int is_safe_type);
+
+/* FetchCommonType.proto */
+static PyTypeObject* __Pyx_FetchCommonTypeFromSpec(PyTypeObject *metaclass, PyObject *module, PyType_Spec *spec, PyObject *bases);
+
+/* CommonTypesMetaclass.proto */
+static int __pyx_CommonTypesMetaclass_init(PyObject *module);
+#define __Pyx_CommonTypesMetaclass_USED
+
+/* CallTypeTraverse.proto */
+#if !CYTHON_USE_TYPE_SPECS || (!CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x03090000)
+#define __Pyx_call_type_traverse(o, always_call, visit, arg) 0
 #else
-#define __Pyx_SetNameInClass(ns, name, value)  PyObject_SetItem(ns, name, value)
+static int __Pyx_call_type_traverse(PyObject *o, int always_call, visitproc visit, void *arg);
 #endif
 
-/* FetchCommonType.proto */
-static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type);
+/* PyMethodNew.proto */
+static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ);
 
-/* CythonFunction.proto */
-#define __Pyx_CyFunction_USED 1
+/* PyVectorcallFastCallDict.proto */
+#if CYTHON_METH_FASTCALL && (CYTHON_VECTORCALL || CYTHON_BACKPORT_VECTORCALL)
+static CYTHON_INLINE PyObject *__Pyx_PyVectorcall_FastCallDict(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw);
+#endif
+
+/* CythonFunctionShared.proto */
+#define __Pyx_CyFunction_USED
 #define __Pyx_CYFUNCTION_STATICMETHOD  0x01
 #define __Pyx_CYFUNCTION_CLASSMETHOD   0x02
 #define __Pyx_CYFUNCTION_CCLASS        0x04
+#define __Pyx_CYFUNCTION_COROUTINE     0x08
 #define __Pyx_CyFunction_GetClosure(f)\
     (((__pyx_CyFunctionObject *) (f))->func_closure)
-#define __Pyx_CyFunction_GetClassObj(f)\
-    (((__pyx_CyFunctionObject *) (f))->func_classobj)
+#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API
+  #define __Pyx_CyFunction_GetClassObj(f)\
+      (((__pyx_CyFunctionObject *) (f))->func_classobj)
+#else
+  #define __Pyx_CyFunction_GetClassObj(f)\
+      ((PyObject*) ((PyCMethodObject *) (f))->mm_class)
+#endif
+#define __Pyx_CyFunction_SetClassObj(f, classobj)\
+    __Pyx__CyFunction_SetClassObj((__pyx_CyFunctionObject *) (f), (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 {
+#if CYTHON_COMPILING_IN_LIMITED_API
+    PyObject_HEAD
+    PyObject *func;
+#elif PY_VERSION_HEX < 0x030900B1
     PyCFunctionObject func;
-#if PY_VERSION_HEX < 0x030500A0
+#else
+    PyCMethodObject func;
+#endif
+#if CYTHON_BACKPORT_VECTORCALL ||\
+        (CYTHON_COMPILING_IN_LIMITED_API && CYTHON_METH_FASTCALL)
+    __pyx_vectorcallfunc func_vectorcall;
+#endif
+#if CYTHON_COMPILING_IN_LIMITED_API
     PyObject *func_weakreflist;
 #endif
     PyObject *func_dict;
@@ -1489,34 +2372,87 @@ typedef struct {
     PyObject *func_globals;
     PyObject *func_code;
     PyObject *func_closure;
+#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API
     PyObject *func_classobj;
-    void *defaults;
-    int defaults_pyobjects;
+#endif
+    PyObject *defaults;
     int flags;
     PyObject *defaults_tuple;
     PyObject *defaults_kwdict;
     PyObject *(*defaults_getter)(PyObject *);
     PyObject *func_annotations;
+    PyObject *func_is_coroutine;
 } __pyx_CyFunctionObject;
-static PyTypeObject *__pyx_CyFunctionType = 0;
-#define __Pyx_CyFunction_Check(obj)  (__Pyx_TypeCheck(obj, __pyx_CyFunctionType))
-#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,
+#undef __Pyx_CyOrPyCFunction_Check
+#define __Pyx_CyFunction_Check(obj)  __Pyx_TypeCheck(obj, __pyx_mstate_global->__pyx_CyFunctionType)
+#define __Pyx_CyOrPyCFunction_Check(obj)  __Pyx_TypeCheck2(obj, __pyx_mstate_global->__pyx_CyFunctionType, &PyCFunction_Type)
+#define __Pyx_CyFunction_CheckExact(obj)  __Pyx_IS_TYPE(obj, __pyx_mstate_global->__pyx_CyFunctionType)
+static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void (*cfunc)(void));
+#undef __Pyx_IsSameCFunction
+#define __Pyx_IsSameCFunction(func, cfunc)   __Pyx__IsSameCyOrCFunction(func, cfunc)
+static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject* op, PyMethodDef *ml,
                                       int flags, PyObject* qualname,
-                                      PyObject *self,
+                                      PyObject *closure,
                                       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_SetClassObj(__pyx_CyFunctionObject* f, PyObject* classobj);
+static CYTHON_INLINE PyObject *__Pyx_CyFunction_InitDefaults(PyObject *func,
+                                                         PyTypeObject *defaults_type);
 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);
+static int __pyx_CyFunction_init(PyObject *module);
+#if CYTHON_METH_FASTCALL
+static PyObject * __Pyx_CyFunction_Vectorcall_NOARGS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames);
+static PyObject * __Pyx_CyFunction_Vectorcall_O(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames);
+static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames);
+static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames);
+#if CYTHON_BACKPORT_VECTORCALL || CYTHON_COMPILING_IN_LIMITED_API
+#define __Pyx_CyFunction_func_vectorcall(f) (((__pyx_CyFunctionObject*)f)->func_vectorcall)
+#else
+#define __Pyx_CyFunction_func_vectorcall(f) (((PyCFunctionObject*)f)->vectorcall)
+#endif
+#endif
+
+/* CythonFunction.proto */
+static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml,
+                                      int flags, PyObject* qualname,
+                                      PyObject *closure,
+                                      PyObject *module, PyObject *globals,
+                                      PyObject* code);
+
+/* Py3UpdateBases.proto */
+static PyObject* __Pyx_PEP560_update_bases(PyObject *bases);
+
+/* CalculateMetaclass.proto */
+static PyObject *__Pyx_CalculateMetaclass(PyTypeObject *metaclass, PyObject *bases);
+
+/* SetNameInClass.proto */
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030d0000
+#define __Pyx_SetNameInClass(ns, name, value)\
+    (likely(PyDict_CheckExact(ns)) ? _PyDict_SetItem_KnownHash(ns, name, value, ((PyASCIIObject *) name)->hash) : PyObject_SetItem(ns, name, value))
+#elif CYTHON_COMPILING_IN_CPYTHON
+#define __Pyx_SetNameInClass(ns, name, value)\
+    (likely(PyDict_CheckExact(ns)) ? PyDict_SetItem(ns, name, value) : PyObject_SetItem(ns, name, value))
+#else
+#define __Pyx_SetNameInClass(ns, name, value)  PyObject_SetItem(ns, name, value)
+#endif
+
+/* PyObjectCall2Args.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2);
+
+/* PyObjectLookupSpecial.proto */
+#if CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS
+#define __Pyx_PyObject_LookupSpecialNoError(obj, attr_name)  __Pyx__PyObject_LookupSpecial(obj, attr_name, 0)
+#define __Pyx_PyObject_LookupSpecial(obj, attr_name)  __Pyx__PyObject_LookupSpecial(obj, attr_name, 1)
+static CYTHON_INLINE PyObject* __Pyx__PyObject_LookupSpecial(PyObject* obj, PyObject* attr_name, int with_error);
+#else
+#define __Pyx_PyObject_LookupSpecialNoError(o,n) __Pyx_PyObject_GetAttrStrNoError(o,n)
+#define __Pyx_PyObject_LookupSpecial(o,n) __Pyx_PyObject_GetAttrStr(o,n)
+#endif
 
 /* Py3ClassCreate.proto */
 static PyObject *__Pyx_Py3MetaclassPrepare(PyObject *metaclass, PyObject *bases, PyObject *name, PyObject *qualname,
@@ -1524,62 +2460,61 @@ static PyObject *__Pyx_Py3MetaclassPrepare(PyObject *metaclass, PyObject *bases,
 static PyObject *__Pyx_Py3ClassCreate(PyObject *metaclass, PyObject *name, PyObject *bases, PyObject *dict,
                                       PyObject *mkw, int calculate_metaclass, int allow_py2_metaclass);
 
+/* ListPack.proto */
+static PyObject *__Pyx_PyList_Pack(Py_ssize_t n, ...);
+
 /* Import.proto */
 static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level);
 
 /* ImportFrom.proto */
 static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name);
 
+/* ImportDottedModule.proto */
+static PyObject *__Pyx_ImportDottedModule(PyObject *name, PyObject *parts_tuple);
+static PyObject *__Pyx_ImportDottedModule_WalkParts(PyObject *module, PyObject *name, PyObject *parts_tuple);
+
+/* ImportDottedModuleRelFirst.proto */
+static PyObject *__Pyx_ImportDottedModuleRelFirst(PyObject *name, PyObject *parts_tuple);
+
+/* PyObjectCallMethod1.proto */
+static PyObject* __Pyx_PyObject_CallMethod1(PyObject* obj, PyObject* method_name, PyObject* arg);
+
+/* append.proto */
+static CYTHON_INLINE int __Pyx_PyObject_Append(PyObject* L, PyObject* x);
+
 /* CLineInTraceback.proto */
-#ifdef CYTHON_CLINE_IN_TRACEBACK
-#define __Pyx_CLineForTraceback(tstate, c_line)  (((CYTHON_CLINE_IN_TRACEBACK)) ? c_line : 0)
-#else
+#if CYTHON_CLINE_IN_TRACEBACK && CYTHON_CLINE_IN_TRACEBACK_RUNTIME
 static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line);
+#else
+#define __Pyx_CLineForTraceback(tstate, c_line)  (((CYTHON_CLINE_IN_TRACEBACK)) ? c_line : 0)
 #endif
 
 /* CodeObjectCache.proto */
+#if CYTHON_COMPILING_IN_LIMITED_API
+typedef PyObject __Pyx_CachedCodeObjectType;
+#else
+typedef PyCodeObject __Pyx_CachedCodeObjectType;
+#endif
 typedef struct {
-    PyCodeObject* code_object;
+    __Pyx_CachedCodeObjectType* code_object;
     int code_line;
 } __Pyx_CodeObjectCacheEntry;
 struct __Pyx_CodeObjectCache {
     int count;
     int max_count;
     __Pyx_CodeObjectCacheEntry* entries;
+  #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING
+    __pyx_atomic_int_type accessor_count;
+  #endif
 };
-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);
+static __Pyx_CachedCodeObjectType *__pyx_find_code_object(int code_line);
+static void __pyx_insert_code_object(int code_line, __Pyx_CachedCodeObjectType* code_object);
 
 /* AddTraceback.proto */
 static void __Pyx_AddTraceback(const char *funcname, int c_line,
                                int py_line, const char *filename);
 
-/* CIntToPy.proto */
-static CYTHON_INLINE PyObject* __Pyx_PyInt_From_TA_RetCode(TA_RetCode value);
-
-/* CIntToPy.proto */
-static CYTHON_INLINE PyObject* __Pyx_PyInt_From_unsigned_int(unsigned int value);
-
-/* CIntToPy.proto */
-static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value);
-
-/* CIntToPy.proto */
-static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value);
-
-/* CIntToPy.proto */
-static CYTHON_INLINE PyObject* __Pyx_PyInt_From_TA_OptInputParameterType(TA_OptInputParameterType value);
-
-/* CIntToPy.proto */
-static CYTHON_INLINE PyObject* __Pyx_PyInt_From_TA_FuncFlags(TA_FuncFlags value);
-
-/* CIntToPy.proto */
-static CYTHON_INLINE PyObject* __Pyx_PyInt_From_TA_InputFlags(TA_InputFlags value);
-
-/* CIntToPy.proto */
-static CYTHON_INLINE PyObject* __Pyx_PyInt_From_TA_OutputFlags(TA_OutputFlags value);
-
 /* RealImag.proto */
 #if CYTHON_CCOMPLEX
   #ifdef __cplusplus
@@ -1603,7 +2538,7 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_TA_OutputFlags(TA_OutputFlags va
 #endif
 
 /* Arithmetic.proto */
-#if CYTHON_CCOMPLEX
+#if CYTHON_CCOMPLEX && (1) && (!0 || __cplusplus)
     #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))
@@ -1641,7 +2576,7 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_TA_OutputFlags(TA_OutputFlags va
 #endif
 
 /* Arithmetic.proto */
-#if CYTHON_CCOMPLEX
+#if CYTHON_CCOMPLEX && (1) && (!0 || __cplusplus)
     #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))
@@ -1678,84 +2613,226 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_TA_OutputFlags(TA_OutputFlags va
     #endif
 #endif
 
-/* CIntToPy.proto */
-static CYTHON_INLINE PyObject* __Pyx_PyInt_From_enum__NPY_TYPES(enum NPY_TYPES value);
+/* Arithmetic.proto */
+#if CYTHON_CCOMPLEX && (1) && (!0 || __cplusplus)
+    #define __Pyx_c_eq_long__double(a, b)   ((a)==(b))
+    #define __Pyx_c_sum_long__double(a, b)  ((a)+(b))
+    #define __Pyx_c_diff_long__double(a, b) ((a)-(b))
+    #define __Pyx_c_prod_long__double(a, b) ((a)*(b))
+    #define __Pyx_c_quot_long__double(a, b) ((a)/(b))
+    #define __Pyx_c_neg_long__double(a)     (-(a))
+  #ifdef __cplusplus
+    #define __Pyx_c_is_zero_long__double(z) ((z)==(long double)0)
+    #define __Pyx_c_conj_long__double(z)    (::std::conj(z))
+    #if 1
+        #define __Pyx_c_abs_long__double(z)     (::std::abs(z))
+        #define __Pyx_c_pow_long__double(a, b)  (::std::pow(a, b))
+    #endif
+  #else
+    #define __Pyx_c_is_zero_long__double(z) ((z)==0)
+    #define __Pyx_c_conj_long__double(z)    (conjl(z))
+    #if 1
+        #define __Pyx_c_abs_long__double(z)     (cabsl(z))
+        #define __Pyx_c_pow_long__double(a, b)  (cpowl(a, b))
+    #endif
+ #endif
+#else
+    static CYTHON_INLINE int __Pyx_c_eq_long__double(__pyx_t_long_double_complex, __pyx_t_long_double_complex);
+    static CYTHON_INLINE __pyx_t_long_double_complex __Pyx_c_sum_long__double(__pyx_t_long_double_complex, __pyx_t_long_double_complex);
+    static CYTHON_INLINE __pyx_t_long_double_complex __Pyx_c_diff_long__double(__pyx_t_long_double_complex, __pyx_t_long_double_complex);
+    static CYTHON_INLINE __pyx_t_long_double_complex __Pyx_c_prod_long__double(__pyx_t_long_double_complex, __pyx_t_long_double_complex);
+    static CYTHON_INLINE __pyx_t_long_double_complex __Pyx_c_quot_long__double(__pyx_t_long_double_complex, __pyx_t_long_double_complex);
+    static CYTHON_INLINE __pyx_t_long_double_complex __Pyx_c_neg_long__double(__pyx_t_long_double_complex);
+    static CYTHON_INLINE int __Pyx_c_is_zero_long__double(__pyx_t_long_double_complex);
+    static CYTHON_INLINE __pyx_t_long_double_complex __Pyx_c_conj_long__double(__pyx_t_long_double_complex);
+    #if 1
+        static CYTHON_INLINE long double __Pyx_c_abs_long__double(__pyx_t_long_double_complex);
+        static CYTHON_INLINE __pyx_t_long_double_complex __Pyx_c_pow_long__double(__pyx_t_long_double_complex, __pyx_t_long_double_complex);
+    #endif
+#endif
 
 /* CIntFromPy.proto */
-static CYTHON_INLINE TA_RetCode __Pyx_PyInt_As_TA_RetCode(PyObject *);
+static CYTHON_INLINE TA_RetCode __Pyx_PyLong_As_TA_RetCode(PyObject *);
 
 /* CIntFromPy.proto */
-static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *);
+static CYTHON_INLINE int __Pyx_PyLong_As_int(PyObject *);
+
+/* CIntToPy.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyLong_From_int(int value);
+
+/* CIntToPy.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyLong_From_TA_RetCode(TA_RetCode value);
 
 /* CIntFromPy.proto */
-static CYTHON_INLINE TA_FuncUnstId __Pyx_PyInt_As_TA_FuncUnstId(PyObject *);
+static CYTHON_INLINE TA_FuncUnstId __Pyx_PyLong_As_TA_FuncUnstId(PyObject *);
 
 /* CIntFromPy.proto */
-static CYTHON_INLINE unsigned int __Pyx_PyInt_As_unsigned_int(PyObject *);
+static CYTHON_INLINE unsigned int __Pyx_PyLong_As_unsigned_int(PyObject *);
+
+/* CIntToPy.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyLong_From_unsigned_int(unsigned int value);
 
 /* CIntFromPy.proto */
-static CYTHON_INLINE TA_Compatibility __Pyx_PyInt_As_TA_Compatibility(PyObject *);
+static CYTHON_INLINE TA_Compatibility __Pyx_PyLong_As_TA_Compatibility(PyObject *);
 
 /* CIntFromPy.proto */
-static CYTHON_INLINE TA_CandleSettingType __Pyx_PyInt_As_TA_CandleSettingType(PyObject *);
+static CYTHON_INLINE TA_CandleSettingType __Pyx_PyLong_As_TA_CandleSettingType(PyObject *);
 
 /* CIntFromPy.proto */
-static CYTHON_INLINE TA_RangeType __Pyx_PyInt_As_TA_RangeType(PyObject *);
+static CYTHON_INLINE TA_RangeType __Pyx_PyLong_As_TA_RangeType(PyObject *);
+
+/* CIntToPy.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyLong_From_long(long value);
+
+/* CIntToPy.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyLong_From_TA_OptInputParameterType(TA_OptInputParameterType value);
+
+/* CIntToPy.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyLong_From_TA_FuncFlags(TA_FuncFlags value);
+
+/* CIntToPy.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyLong_From_TA_InputFlags(TA_InputFlags value);
+
+/* CIntToPy.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyLong_From_TA_OutputFlags(TA_OutputFlags value);
+
+/* FormatTypeName.proto */
+#if CYTHON_COMPILING_IN_LIMITED_API
+typedef PyObject *__Pyx_TypeName;
+#define __Pyx_FMT_TYPENAME "%U"
+#define __Pyx_DECREF_TypeName(obj) Py_XDECREF(obj)
+#if __PYX_LIMITED_VERSION_HEX >= 0x030d0000
+#define __Pyx_PyType_GetFullyQualifiedName PyType_GetFullyQualifiedName
+#else
+static __Pyx_TypeName __Pyx_PyType_GetFullyQualifiedName(PyTypeObject* tp);
+#endif
+#else  // !LIMITED_API
+typedef const char *__Pyx_TypeName;
+#define __Pyx_FMT_TYPENAME "%.200s"
+#define __Pyx_PyType_GetFullyQualifiedName(tp) ((tp)->tp_name)
+#define __Pyx_DECREF_TypeName(obj)
+#endif
 
 /* CIntFromPy.proto */
-static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *);
+static CYTHON_INLINE long __Pyx_PyLong_As_long(PyObject *);
 
 /* FastTypeChecks.proto */
 #if CYTHON_COMPILING_IN_CPYTHON
 #define __Pyx_TypeCheck(obj, type) __Pyx_IsSubtype(Py_TYPE(obj), (PyTypeObject *)type)
+#define __Pyx_TypeCheck2(obj, type1, type2) __Pyx_IsAnySubtype2(Py_TYPE(obj), (PyTypeObject *)type1, (PyTypeObject *)type2)
 static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b);
+static CYTHON_INLINE int __Pyx_IsAnySubtype2(PyTypeObject *cls, PyTypeObject *a, PyTypeObject *b);
 static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject *type);
 static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *type1, PyObject *type2);
 #else
 #define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type)
+#define __Pyx_TypeCheck2(obj, type1, type2) (PyObject_TypeCheck(obj, (PyTypeObject *)type1) || PyObject_TypeCheck(obj, (PyTypeObject *)type2))
 #define __Pyx_PyErr_GivenExceptionMatches(err, type) PyErr_GivenExceptionMatches(err, type)
-#define __Pyx_PyErr_GivenExceptionMatches2(err, type1, type2) (PyErr_GivenExceptionMatches(err, type1) || PyErr_GivenExceptionMatches(err, type2))
+static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *type1, PyObject *type2) {
+    return PyErr_GivenExceptionMatches(err, type1) || PyErr_GivenExceptionMatches(err, type2);
+}
 #endif
+#define __Pyx_PyErr_ExceptionMatches2(err1, err2)  __Pyx_PyErr_GivenExceptionMatches2(__Pyx_PyErr_CurrentExceptionType(), err1, err2)
 #define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception)
+#ifdef PyExceptionInstance_Check
+  #define __Pyx_PyBaseException_Check(obj) PyExceptionInstance_Check(obj)
+#else
+  #define __Pyx_PyBaseException_Check(obj) __Pyx_TypeCheck(obj, PyExc_BaseException)
+#endif
 
-/* CheckBinaryVersion.proto */
-static int __Pyx_check_binary_version(void);
-
-/* InitStrings.proto */
-static int __Pyx_InitStrings(__Pyx_StringTabEntry *t);
+/* GetRuntimeVersion.proto */
+static unsigned long __Pyx_get_runtime_version(void);
 
+/* CheckBinaryVersion.proto */
+static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt_version, int allow_newer);
+
+/* MultiPhaseInitModuleState.proto */
+#if CYTHON_PEP489_MULTI_PHASE_INIT && CYTHON_USE_MODULE_STATE
+static PyObject *__Pyx_State_FindModule(void*);
+static int __Pyx_State_AddModule(PyObject* module, void*);
+static int __Pyx_State_RemoveModule(void*);
+#elif CYTHON_USE_MODULE_STATE
+#define __Pyx_State_FindModule PyState_FindModule
+#define __Pyx_State_AddModule PyState_AddModule
+#define __Pyx_State_RemoveModule PyState_RemoveModule
+#endif
 
-/* Module declarations from 'cpython.buffer' */
+/* #### Code section: module_declarations ### */
+/* CythonABIVersion.proto */
+#if CYTHON_COMPILING_IN_LIMITED_API
+    #if CYTHON_METH_FASTCALL
+        #define __PYX_FASTCALL_ABI_SUFFIX  "_fastcall"
+    #else
+        #define __PYX_FASTCALL_ABI_SUFFIX
+    #endif
+    #define __PYX_LIMITED_ABI_SUFFIX "limited" __PYX_FASTCALL_ABI_SUFFIX __PYX_AM_SEND_ABI_SUFFIX
+#else
+    #define __PYX_LIMITED_ABI_SUFFIX
+#endif
+#if __PYX_HAS_PY_AM_SEND == 1
+    #define __PYX_AM_SEND_ABI_SUFFIX
+#elif __PYX_HAS_PY_AM_SEND == 2
+    #define __PYX_AM_SEND_ABI_SUFFIX "amsendbackport"
+#else
+    #define __PYX_AM_SEND_ABI_SUFFIX "noamsend"
+#endif
+#ifndef __PYX_MONITORING_ABI_SUFFIX
+    #define __PYX_MONITORING_ABI_SUFFIX
+#endif
+#if CYTHON_USE_TP_FINALIZE
+    #define __PYX_TP_FINALIZE_ABI_SUFFIX
+#else
+    #define __PYX_TP_FINALIZE_ABI_SUFFIX "nofinalize"
+#endif
+#if CYTHON_USE_FREELISTS || !defined(__Pyx_AsyncGen_USED)
+    #define __PYX_FREELISTS_ABI_SUFFIX
+#else
+    #define __PYX_FREELISTS_ABI_SUFFIX "nofreelists"
+#endif
+#define CYTHON_ABI  __PYX_ABI_VERSION __PYX_LIMITED_ABI_SUFFIX __PYX_MONITORING_ABI_SUFFIX __PYX_TP_FINALIZE_ABI_SUFFIX __PYX_FREELISTS_ABI_SUFFIX __PYX_AM_SEND_ABI_SUFFIX
+#define __PYX_ABI_MODULE_NAME "_cython_" CYTHON_ABI
+#define __PYX_TYPE_MODULE_PREFIX __PYX_ABI_MODULE_NAME "."
 
-/* Module declarations from 'libc.string' */
+static CYTHON_INLINE npy_intp __pyx_f_5numpy_5dtype_8itemsize_itemsize(PyArray_Descr *__pyx_v_self); /* proto*/
+static CYTHON_INLINE npy_intp __pyx_f_5numpy_5dtype_9alignment_alignment(PyArray_Descr *__pyx_v_self); /* proto*/
+static CYTHON_INLINE PyObject *__pyx_f_5numpy_5dtype_6fields_fields(PyArray_Descr *__pyx_v_self); /* proto*/
+static CYTHON_INLINE PyObject *__pyx_f_5numpy_5dtype_5names_names(PyArray_Descr *__pyx_v_self); /* proto*/
+static CYTHON_INLINE PyArray_ArrayDescr *__pyx_f_5numpy_5dtype_8subarray_subarray(PyArray_Descr *__pyx_v_self); /* proto*/
+static CYTHON_INLINE npy_uint64 __pyx_f_5numpy_5dtype_5flags_flags(PyArray_Descr *__pyx_v_self); /* proto*/
+static CYTHON_INLINE int __pyx_f_5numpy_9broadcast_7numiter_numiter(PyArrayMultiIterObject *__pyx_v_self); /* proto*/
+static CYTHON_INLINE npy_intp __pyx_f_5numpy_9broadcast_4size_size(PyArrayMultiIterObject *__pyx_v_self); /* proto*/
+static CYTHON_INLINE npy_intp __pyx_f_5numpy_9broadcast_5index_index(PyArrayMultiIterObject *__pyx_v_self); /* proto*/
+static CYTHON_INLINE int __pyx_f_5numpy_9broadcast_2nd_nd(PyArrayMultiIterObject *__pyx_v_self); /* proto*/
+static CYTHON_INLINE npy_intp *__pyx_f_5numpy_9broadcast_10dimensions_dimensions(PyArrayMultiIterObject *__pyx_v_self); /* proto*/
+static CYTHON_INLINE void **__pyx_f_5numpy_9broadcast_5iters_iters(PyArrayMultiIterObject *__pyx_v_self); /* proto*/
+static CYTHON_INLINE PyObject *__pyx_f_5numpy_7ndarray_4base_base(PyArrayObject *__pyx_v_self); /* proto*/
+static CYTHON_INLINE PyArray_Descr *__pyx_f_5numpy_7ndarray_5descr_descr(PyArrayObject *__pyx_v_self); /* proto*/
+static CYTHON_INLINE int __pyx_f_5numpy_7ndarray_4ndim_ndim(PyArrayObject *__pyx_v_self); /* proto*/
+static CYTHON_INLINE npy_intp *__pyx_f_5numpy_7ndarray_5shape_shape(PyArrayObject *__pyx_v_self); /* proto*/
+static CYTHON_INLINE npy_intp *__pyx_f_5numpy_7ndarray_7strides_strides(PyArrayObject *__pyx_v_self); /* proto*/
+static CYTHON_INLINE npy_intp __pyx_f_5numpy_7ndarray_4size_size(PyArrayObject *__pyx_v_self); /* proto*/
+static CYTHON_INLINE char *__pyx_f_5numpy_7ndarray_4data_data(PyArrayObject *__pyx_v_self); /* proto*/
 
-/* Module declarations from 'libc.stdio' */
+/* Module declarations from "libc.string" */
 
-/* Module declarations from '__builtin__' */
+/* Module declarations from "libc.stdio" */
 
-/* Module declarations from 'cpython.type' */
-static PyTypeObject *__pyx_ptype_7cpython_4type_type = 0;
+/* Module declarations from "__builtin__" */
 
-/* Module declarations from 'cpython' */
+/* Module declarations from "cpython.type" */
 
-/* Module declarations from 'cpython.object' */
+/* Module declarations from "cpython" */
 
-/* Module declarations from 'cpython.ref' */
+/* Module declarations from "cpython.object" */
 
-/* Module declarations from 'cpython.mem' */
+/* Module declarations from "cpython.ref" */
 
-/* Module declarations from 'numpy' */
+/* 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 "numpy" */
 static CYTHON_INLINE int __pyx_f_5numpy_import_array(void); /*proto*/
 
-/* Module declarations from 'talib._ta_lib' */
+/* Module declarations from "talib._ta_lib" */
 static double __pyx_v_5talib_7_ta_lib_NaN;
 static PyObject *__pyx_f_5talib_7_ta_lib__ta_check_success(PyObject *, TA_RetCode, int __pyx_skip_dispatch); /*proto*/
 static PyArrayObject *__pyx_f_5talib_7_ta_lib_check_array(PyArrayObject *); /*proto*/
@@ -1768,49 +2845,62 @@ static npy_int __pyx_f_5talib_7_ta_lib_check_begidx3(npy_intp, double *, double
 static npy_int __pyx_f_5talib_7_ta_lib_check_begidx4(npy_intp, double *, double *, double *, double *); /*proto*/
 static PyArrayObject *__pyx_f_5talib_7_ta_lib_make_double_array(npy_intp, int); /*proto*/
 static PyArrayObject *__pyx_f_5talib_7_ta_lib_make_int_array(npy_intp, int); /*proto*/
-static TA_FuncHandle *__pyx_f_5talib_7_ta_lib___ta_getFuncHandle(char *); /*proto*/
+static TA_FuncHandle const *__pyx_f_5talib_7_ta_lib___ta_getFuncHandle(char *); /*proto*/
 static TA_ParamHolder *__pyx_f_5talib_7_ta_lib___ta_paramHolderAlloc(char *); /*proto*/
 static int __pyx_f_5talib_7_ta_lib___ta_paramHolderFree(TA_ParamHolder *); /*proto*/
 static int __pyx_f_5talib_7_ta_lib___ta_setOptInputParamInteger(TA_ParamHolder *, int, int); /*proto*/
-static int __pyx_f_5talib_7_ta_lib___ta_setOptInputParamReal(TA_ParamHolder *, int, int); /*proto*/
+static int __pyx_f_5talib_7_ta_lib___ta_setOptInputParamReal(TA_ParamHolder *, int, double); /*proto*/
 static int __pyx_f_5talib_7_ta_lib___ta_getLookback(TA_ParamHolder *); /*proto*/
+/* #### Code section: typeinfo ### */
+/* #### Code section: before_global_var ### */
 #define __Pyx_MODULE_NAME "talib._ta_lib"
 extern int __pyx_module_is_main_talib___ta_lib;
 int __pyx_module_is_main_talib___ta_lib = 0;
 
-/* Implementation of 'talib._ta_lib' */
+/* Implementation of "talib._ta_lib" */
+/* #### Code section: global_var ### */
 static PyObject *__pyx_builtin_object;
 static PyObject *__pyx_builtin_range;
 static PyObject *__pyx_builtin_enumerate;
 static PyObject *__pyx_builtin_ImportError;
+static PyObject *__pyx_builtin_ModuleNotFoundError;
+static PyObject *__pyx_builtin_NameError;
 static PyObject *__pyx_builtin_property;
 static PyObject *__pyx_builtin_xrange;
 static PyObject *__pyx_builtin_IndexError;
 static PyObject *__pyx_builtin_TypeError;
 static PyObject *__pyx_builtin_min;
 static PyObject *__pyx_builtin_max;
-static PyObject *__pyx_builtin_ValueError;
-static PyObject *__pyx_builtin_RuntimeError;
+/* #### Code section: string_decls ### */
+static const char __pyx_k_[] = ": ";
 static const char __pyx_k_3[] = "3";
 static const char __pyx_k_b[] = "b";
+static const char __pyx_k_d[] = "d";
 static const char __pyx_k_i[] = "i";
+static const char __pyx_k_n[] = "n";
 static const char __pyx_k_s[] = "s";
 static const char __pyx_k_AD[] = "AD";
 static const char __pyx_k_DX[] = "DX";
 static const char __pyx_k_LN[] = "LN";
 static const char __pyx_k_MA[] = "MA";
 static const char __pyx_k_T3[] = "T3";
-static const char __pyx_k__5[] = "";
-static const char __pyx_k__6[] = ", ";
-static const char __pyx_k__8[] = "(";
-static const char __pyx_k__9[] = " ";
+static const char __pyx_k__2[] = "";
+static const char __pyx_k__3[] = ", ";
+static const char __pyx_k__4[] = " (";
+static const char __pyx_k__5[] = ")";
+static const char __pyx_k__6[] = "(";
+static const char __pyx_k__7[] = "    ";
+static const char __pyx_k__8[] = "[";
+static const char __pyx_k__9[] = "=";
 static const char __pyx_k_id[] = "id";
 static const char __pyx_k_in[] = "in";
+static const char __pyx_k_1_1[] = "\200\001\340\004\017\320\017#\2401\330\004\013\2101";
 static const char __pyx_k_ADD[] = "ADD";
 static const char __pyx_k_ADX[] = "ADX";
 static const char __pyx_k_ALL[] = "ALL";
 static const char __pyx_k_APO[] = "APO";
 static const char __pyx_k_ATR[] = "ATR";
+static const char __pyx_k_A_q[] = "\200A\330\010\017\210q";
 static const char __pyx_k_BOP[] = "BOP";
 static const char __pyx_k_CCI[] = "CCI";
 static const char __pyx_k_CMO[] = "CMO";
@@ -1820,12 +2910,14 @@ static const char __pyx_k_Dot[] = "Dot";
 static const char __pyx_k_EMA[] = "EMA";
 static const char __pyx_k_EXP[] = "EXP";
 static const char __pyx_k_Far[] = "Far";
+static const char __pyx_k_IMI[] = "IMI";
 static const char __pyx_k_MAX[] = "MAX";
 static const char __pyx_k_MFI[] = "MFI";
 static const char __pyx_k_MIN[] = "MIN";
 static const char __pyx_k_MOM[] = "MOM";
 static const char __pyx_k_OBV[] = "OBV";
 static const char __pyx_k_PPO[] = "PPO";
+static const char __pyx_k_Q_q[] = "\200\001\340\004\022\220.\240\001\330\004\025\220Q\320\026'\240q";
 static const char __pyx_k_ROC[] = "ROC";
 static const char __pyx_k_RSI[] = "RSI";
 static const char __pyx_k_SAR[] = "SAR";
@@ -1837,10 +2929,16 @@ static const char __pyx_k_TAN[] = "TAN";
 static const char __pyx_k_TSF[] = "TSF";
 static const char __pyx_k_VAR[] = "VAR";
 static const char __pyx_k_WMA[] = "WMA";
-static const char __pyx_k__10[] = ")\n";
-static const char __pyx_k__11[] = "\n";
+static const char __pyx_k__10[] = "]";
+static const char __pyx_k__11[] = " ";
+static const char __pyx_k__12[] = ")\n";
+static const char __pyx_k__13[] = "\n";
+static const char __pyx_k__14[] = ".";
+static const char __pyx_k__15[] = "?";
+static const char __pyx_k_all[] = "__all__";
 static const char __pyx_k_arg[] = "arg";
 static const char __pyx_k_doc[] = "__doc__";
+static const char __pyx_k_got[] = ", got ";
 static const char __pyx_k_idx[] = "idx";
 static const char __pyx_k_key[] = "key";
 static const char __pyx_k_log[] = "log";
@@ -1856,13 +2954,13 @@ static const char __pyx_k_run[] = "run";
 static const char __pyx_k_s_2[] = "%s";
 static const char __pyx_k_s_3[] = "(%s)";
 static const char __pyx_k_s_4[] = "    %s";
-static const char __pyx_k_s_s[] = "    %s: %s";
 static const char __pyx_k_str[] = "__str__";
 static const char __pyx_k_sys[] = "sys";
 static const char __pyx_k_ACOS[] = "ACOS";
 static const char __pyx_k_ADXR[] = "ADXR";
 static const char __pyx_k_ASIN[] = "ASIN";
 static const char __pyx_k_ATAN[] = "ATAN";
+static const char __pyx_k_A_Qd[] = "\200A\330\010\017\320\017%\240Q\240d\250&\260\001\260\021";
 static const char __pyx_k_BETA[] = "BETA";
 static const char __pyx_k_CEIL[] = "CEIL";
 static const char __pyx_k_COSH[] = "COSH";
@@ -1876,6 +2974,7 @@ static const char __pyx_k_MULT[] = "MULT";
 static const char __pyx_k_NATR[] = "NATR";
 static const char __pyx_k_NONE[] = "NONE";
 static const char __pyx_k_Near[] = "Near";
+static const char __pyx_k_None[] = "None";
 static const char __pyx_k_ROCP[] = "ROCP";
 static const char __pyx_k_ROCR[] = "ROCR";
 static const char __pyx_k_SINH[] = "SINH";
@@ -1888,11 +2987,11 @@ static const char __pyx_k_call[] = "__call__";
 static const char __pyx_k_copy[] = "copy";
 static const char __pyx_k_docs[] = "docs";
 static const char __pyx_k_flag[] = "flag";
+static const char __pyx_k_func[] = "__func__";
 static const char __pyx_k_help[] = "help";
 static const char __pyx_k_high[] = "high";
 static const char __pyx_k_info[] = "info";
 static const char __pyx_k_init[] = "__init__";
-static const char __pyx_k_join[] = "join";
 static const char __pyx_k_keys[] = "keys";
 static const char __pyx_k_main[] = "__main__";
 static const char __pyx_k_math[] = "math";
@@ -1901,10 +3000,15 @@ static const char __pyx_k_open[] = "open";
 static const char __pyx_k_real[] = "real";
 static const char __pyx_k_repr[] = "__repr__";
 static const char __pyx_k_self[] = "self";
+static const char __pyx_k_spec[] = "__spec__";
 static const char __pyx_k_test[] = "__test__";
 static const char __pyx_k_type[] = "type_";
 static const char __pyx_k_ADOSC[] = "ADOSC";
 static const char __pyx_k_AROON[] = "AROON";
+static const char __pyx_k_A_q_q[] = "\200A\330\010\017\210q\220\007\220q\230\001";
+static const char __pyx_k_A_t85[] = "\200A\360\n\000\t\020\210t\2208\2305\240\001\240\021";
+static const char __pyx_k_A_uAS[] = "\200A\330\010\017\210u\220A\220S\230\001";
+static const char __pyx_k_A_uBd[] = "\200A\330\010\017\210u\220B\220d\230!";
 static const char __pyx_k_Equal[] = "Equal";
 static const char __pyx_k_FLOOR[] = "FLOOR";
 static const char __pyx_k_LOG10[] = "LOG10";
@@ -1916,12 +3020,16 @@ static const char __pyx_k_TA_MA[] = "TA_MA";
 static const char __pyx_k_TA_T3[] = "TA_T3";
 static const char __pyx_k_TRIMA[] = "TRIMA";
 static const char __pyx_k_WILLR[] = "WILLR";
+static const char __pyx_k_a_QoQ[] = "\200\001\340\004\022\220,\230a\330\004\025\220Q\220o\240Q";
 static const char __pyx_k_ascii[] = "ascii";
+static const char __pyx_k_clone[] = "clone";
 static const char __pyx_k_close[] = "close";
+static const char __pyx_k_empty[] = "empty";
 static const char __pyx_k_flags[] = "flags";
 static const char __pyx_k_group[] = "group";
 static const char __pyx_k_index[] = "index";
 static const char __pyx_k_items[] = "items";
+static const char __pyx_k_local[] = "local";
 static const char __pyx_k_lower[] = "lower";
 static const char __pyx_k_nbdev[] = "nbdev";
 static const char __pyx_k_numpy[] = "numpy";
@@ -1931,10 +3039,11 @@ static const char __pyx_k_price[] = "price";
 static const char __pyx_k_range[] = "range";
 static const char __pyx_k_real0[] = "real0";
 static const char __pyx_k_real1[] = "real1";
-static const char __pyx_k_s_s_2[] = "[%s=%s]";
 static const char __pyx_k_table[] = "table";
 static const char __pyx_k_upper[] = "upper";
 static const char __pyx_k_value[] = "value";
+static const char __pyx_k_AVGDEV[] = "AVGDEV";
+static const char __pyx_k_A_t81A[] = "\200A\330\010\017\210t\2208\2301\230A";
 static const char __pyx_k_BBANDS[] = "BBANDS";
 static const char __pyx_k_CORREL[] = "CORREL";
 static const char __pyx_k_Inputs[] = "Inputs:";
@@ -1954,6 +3063,7 @@ static const char __pyx_k_TA_COS[] = "TA_COS";
 static const char __pyx_k_TA_DIV[] = "TA_DIV";
 static const char __pyx_k_TA_EMA[] = "TA_EMA";
 static const char __pyx_k_TA_EXP[] = "TA_EXP";
+static const char __pyx_k_TA_IMI[] = "TA_IMI";
 static const char __pyx_k_TA_MAX[] = "TA_MAX";
 static const char __pyx_k_TA_MFI[] = "TA_MFI";
 static const char __pyx_k_TA_MIN[] = "TA_MIN";
@@ -1973,6 +3083,8 @@ static const char __pyx_k_TA_VAR[] = "TA_VAR";
 static const char __pyx_k_TA_WMA[] = "TA_WMA";
 static const char __pyx_k_TRANGE[] = "TRANGE";
 static const char __pyx_k_ULTOSC[] = "ULTOSC";
+static const char __pyx_k_append[] = "append";
+static const char __pyx_k_aq_Q_Q[] = "\200\001\340\004\022\320\022&\240a\240q\330\004\025\220Q\320\026-\250Q";
 static const char __pyx_k_astype[] = "astype";
 static const char __pyx_k_begidx[] = "begidx";
 static const char __pyx_k_decode[] = "decode";
@@ -1980,7 +3092,6 @@ static const char __pyx_k_endidx[] = "endidx";
 static const char __pyx_k_factor[] = "factor";
 static const char __pyx_k_groups[] = "groups";
 static const char __pyx_k_holder[] = "holder";
-static const char __pyx_k_import[] = "__import__";
 static const char __pyx_k_kwargs[] = "kwargs";
 static const char __pyx_k_length[] = "length";
 static const char __pyx_k_lookup[] = "_lookup";
@@ -1994,15 +3105,19 @@ static const char __pyx_k_output[] = "output";
 static const char __pyx_k_pandas[] = "pandas";
 static const char __pyx_k_params[] = "params";
 static const char __pyx_k_period[] = "period";
+static const char __pyx_k_polars[] = "polars";
 static const char __pyx_k_price0[] = "price0";
 static const char __pyx_k_price1[] = "price1";
 static const char __pyx_k_prices[] = "prices";
+static const char __pyx_k_schema[] = "schema";
 static const char __pyx_k_series[] = "series";
 static const char __pyx_k_type_2[] = "type";
 static const char __pyx_k_update[] = "update";
 static const char __pyx_k_values[] = "values";
 static const char __pyx_k_volume[] = "volume";
-static const char __pyx_k_xrange[] = "xrange";
+static const char __pyx_k_2_1_Q_9[] = "\200\001\340\004\022\320\0222\260!\2601\330\004\025\220Q\320\0269\270\021";
+static const char __pyx_k_A_t85_Q[] = "\200A\360\n\000\t\020\210t\2208\2305\240\005\240Q";
+static const char __pyx_k_A_wat81[] = "\200A\330\010\017\210w\220a\220t\2308\2401";
 static const char __pyx_k_CDLDOJI[] = "CDLDOJI";
 static const char __pyx_k_HT_SINE[] = "HT_SINE";
 static const char __pyx_k_HighLow[] = "HighLow";
@@ -2012,6 +3127,7 @@ static const char __pyx_k_MA_Type[] = "MA_Type";
 static const char __pyx_k_Outputs[] = "Outputs:";
 static const char __pyx_k_PLUS_DI[] = "PLUS_DI";
 static const char __pyx_k_PLUS_DM[] = "PLUS_DM";
+static const char __pyx_k_Qa_Qa_1[] = "\200\001\340\004\034\320\034-\250Q\250a\330\004\020\320\020%\240Q\240a\330\004\013\2101";
 static const char __pyx_k_ROCR100[] = "ROCR100";
 static const char __pyx_k_Shadows[] = "Shadows";
 static const char __pyx_k_TA_ACOS[] = "TA_ACOS";
@@ -2038,9 +3154,11 @@ static const char __pyx_k_TA_TRIX[] = "TA_TRIX";
 static const char __pyx_k_columns[] = "columns";
 static const char __pyx_k_getitem[] = "__getitem__";
 static const char __pyx_k_integer[] = "integer";
+static const char __pyx_k_local_2[] = "__local";
 static const char __pyx_k_max_int[] = "max_int";
 static const char __pyx_k_maximum[] = "maximum";
 static const char __pyx_k_min_int[] = "min_int";
+static const char __pyx_k_missing[] = "missing";
 static const char __pyx_k_nbdevdn[] = "nbdevdn";
 static const char __pyx_k_nbdevup[] = "nbdevup";
 static const char __pyx_k_outfama[] = "outfama";
@@ -2051,12 +3169,14 @@ static const char __pyx_k_outreal[] = "outreal";
 static const char __pyx_k_outsine[] = "outsine";
 static const char __pyx_k_periods[] = "periods";
 static const char __pyx_k_prepare[] = "__prepare__";
+static const char __pyx_k_q_1_Q_a[] = "\200\001\340\004\022\320\022'\240q\250\r\260[\300\013\3101\330\004\025\220Q\320\026.\250a";
 static const char __pyx_k_replace[] = "replace";
 static const char __pyx_k_results[] = "results";
 static const char __pyx_k_retCode[] = "retCode";
 static const char __pyx_k_unicode[] = "__unicode__";
 static const char __pyx_k_version[] = "version";
 static const char __pyx_k_vfactor[] = "vfactor";
+static const char __pyx_k_ACCBANDS[] = "ACCBANDS";
 static const char __pyx_k_AROONOSC[] = "AROONOSC";
 static const char __pyx_k_AVGPRICE[] = "AVGPRICE";
 static const char __pyx_k_BodyDoji[] = "BodyDoji";
@@ -2069,6 +3189,7 @@ static const char __pyx_k_MIDPRICE[] = "MIDPRICE";
 static const char __pyx_k_MININDEX[] = "MININDEX";
 static const char __pyx_k_MINUS_DI[] = "MINUS_DI";
 static const char __pyx_k_MINUS_DM[] = "MINUS_DM";
+static const char __pyx_k_N_1_A_t1[] = "\200N\220!\360\016\000\t\014\2101\330\014\020\320\020!\240\021\240!\330\010\014\320\014\034\230A\330\010\017\210t\2201";
 static const char __pyx_k_RealBody[] = "RealBody";
 static const char __pyx_k_STOCHRSI[] = "STOCHRSI";
 static const char __pyx_k_TA_ADOSC[] = "TA_ADOSC";
@@ -2080,7 +3201,10 @@ static const char __pyx_k_TA_TRIMA[] = "TA_TRIMA";
 static const char __pyx_k_TA_WILLR[] = "TA_WILLR";
 static const char __pyx_k_TYPPRICE[] = "TYPPRICE";
 static const char __pyx_k_WCLPRICE[] = "WCLPRICE";
+static const char __pyx_k_add_note[] = "add_note";
 static const char __pyx_k_defaults[] = "defaults";
+static const char __pyx_k_expected[] = " (expected ";
+static const char __pyx_k_is_empty[] = "is_empty";
 static const char __pyx_k_lookback[] = "lookback";
 static const char __pyx_k_low_data[] = "low_data";
 static const char __pyx_k_outfastd[] = "outfastd";
@@ -2090,6 +3214,9 @@ static const char __pyx_k_outslowk[] = "outslowk";
 static const char __pyx_k_property[] = "property";
 static const char __pyx_k_qualname[] = "__qualname__";
 static const char __pyx_k_ret_code[] = "ret_code";
+static const char __pyx_k_set_name[] = "__set_name__";
+static const char __pyx_k_to_numpy[] = "to_numpy";
+static const char __pyx_k_A_t85_Q_2[] = "\200A\360\n\000\t\020\210t\2208\2305\240\001\240\037\260\005\260Q";
 static const char __pyx_k_BodyShort[] = "BodyShort";
 static const char __pyx_k_CDL2CROWS[] = "CDL2CROWS";
 static const char __pyx_k_CDLHAMMER[] = "CDLHAMMER";
@@ -2101,7 +3228,9 @@ static const char __pyx_k_DataFrame[] = "DataFrame";
 static const char __pyx_k_HT_PHASOR[] = "HT_PHASOR";
 static const char __pyx_k_Histogram[] = "Histogram";
 static const char __pyx_k_LINEARREG[] = "LINEARREG";
+static const char __pyx_k_NameError[] = "NameError";
 static const char __pyx_k_RangeType[] = "RangeType";
+static const char __pyx_k_TA_AVGDEV[] = "TA_AVGDEV";
 static const char __pyx_k_TA_BBANDS[] = "TA_BBANDS";
 static const char __pyx_k_TA_CORREL[] = "TA_CORREL";
 static const char __pyx_k_TA_MINMAX[] = "TA_MINMAX";
@@ -2138,6 +3267,8 @@ static const char __pyx_k_stream_DX[] = "stream_DX";
 static const char __pyx_k_stream_LN[] = "stream_LN";
 static const char __pyx_k_stream_MA[] = "stream_MA";
 static const char __pyx_k_stream_T3[] = "stream_T3";
+static const char __pyx_k_stream__s[] = "stream_%s";
+static const char __pyx_k_threading[] = "threading";
 static const char __pyx_k_timeStamp[] = "timeStamp";
 static const char __pyx_k_CDL3INSIDE[] = "CDL3INSIDE";
 static const char __pyx_k_CDLHIKKAKE[] = "CDLHIKKAKE";
@@ -2147,6 +3278,7 @@ static const char __pyx_k_CDLTRISTAR[] = "CDLTRISTAR";
 static const char __pyx_k_HT_DCPHASE[] = "HT_DCPHASE";
 static const char __pyx_k_IndexError[] = "IndexError";
 static const char __pyx_k_Parameters[] = "Parameters:";
+static const char __pyx_k_Qa_q_A_Q_a[] = "\200\001\340\004\034\320\034-\250Q\250a\330\004\022\320\022'\240q\250\004\250A\330\004\025\220Q\320\026.\250a";
 static const char __pyx_k_ShadowLong[] = "ShadowLong";
 static const char __pyx_k_TA_CDLDOJI[] = "TA_CDLDOJI";
 static const char __pyx_k_TA_HT_SINE[] = "TA_HT_SINE";
@@ -2155,12 +3287,12 @@ static const char __pyx_k_TA_MACDFIX[] = "TA_MACDFIX";
 static const char __pyx_k_TA_PLUS_DI[] = "TA_PLUS_DI";
 static const char __pyx_k_TA_PLUS_DM[] = "TA_PLUS_DM";
 static const char __pyx_k_TA_ROCR100[] = "TA_ROCR100";
-static const char __pyx_k_ValueError[] = "ValueError";
 static const char __pyx_k_close_data[] = "close_data";
 static const char __pyx_k_fastmatype[] = "fastmatype";
 static const char __pyx_k_fastperiod[] = "fastperiod";
 static const char __pyx_k_input_name[] = "input_name";
 static const char __pyx_k_num_inputs[] = "num_inputs";
+static const char __pyx_k_opt_inputs[] = "opt_inputs";
 static const char __pyx_k_outaroonup[] = "outaroonup";
 static const char __pyx_k_outinphase[] = "outinphase";
 static const char __pyx_k_outinteger[] = "outinteger";
@@ -2183,6 +3315,7 @@ static const char __pyx_k_stream_COS[] = "stream_COS";
 static const char __pyx_k_stream_DIV[] = "stream_DIV";
 static const char __pyx_k_stream_EMA[] = "stream_EMA";
 static const char __pyx_k_stream_EXP[] = "stream_EXP";
+static const char __pyx_k_stream_IMI[] = "stream_IMI";
 static const char __pyx_k_stream_MAX[] = "stream_MAX";
 static const char __pyx_k_stream_MFI[] = "stream_MFI";
 static const char __pyx_k_stream_MIN[] = "stream_MIN";
@@ -2217,6 +3350,7 @@ static const char __pyx_k_ImportError[] = "ImportError";
 static const char __pyx_k_MINMAXINDEX[] = "MINMAXINDEX";
 static const char __pyx_k_OrderedDict[] = "OrderedDict";
 static const char __pyx_k_ShadowShort[] = "ShadowShort";
+static const char __pyx_k_TA_ACCBANDS[] = "TA_ACCBANDS";
 static const char __pyx_k_TA_AROONOSC[] = "TA_AROONOSC";
 static const char __pyx_k_TA_AVGPRICE[] = "TA_AVGPRICE";
 static const char __pyx_k_TA_MAXINDEX[] = "TA_MAXINDEX";
@@ -2234,6 +3368,7 @@ static const char __pyx_k_any_ndarray[] = "(any ndarray)";
 static const char __pyx_k_collections[] = "collections";
 static const char __pyx_k_func_object[] = "func_object";
 static const char __pyx_k_input_names[] = "input_names";
+static const char __pyx_k_mro_entries[] = "__mro_entries__";
 static const char __pyx_k_num_outputs[] = "num_outputs";
 static const char __pyx_k_ordereddict[] = "ordereddict";
 static const char __pyx_k_outleadsine[] = "outleadsine";
@@ -2279,7 +3414,6 @@ static const char __pyx_k_Function_run[] = "Function.run";
 static const char __pyx_k_HT_TRENDLINE[] = "HT_TRENDLINE";
 static const char __pyx_k_HT_TRENDMODE[] = "HT_TRENDMODE";
 static const char __pyx_k_Pattern_Bool[] = "Pattern (Bool)";
-static const char __pyx_k_RuntimeError[] = "RuntimeError";
 static const char __pyx_k_TA_CDL2CROWS[] = "TA_CDL2CROWS";
 static const char __pyx_k_TA_CDLHAMMER[] = "TA_CDLHAMMER";
 static const char __pyx_k_TA_CDLHARAMI[] = "TA_CDLHARAMI";
@@ -2294,7 +3428,10 @@ static const char __pyx_k_display_name[] = "display_name";
 static const char __pyx_k_fastd_matype[] = "fastd_matype";
 static const char __pyx_k_fastd_period[] = "fastd_period";
 static const char __pyx_k_fastk_period[] = "fastk_period";
+static const char __pyx_k_import_error[] = "import_error";
+static const char __pyx_k_initializing[] = "_initializing";
 static const char __pyx_k_input_arrays[] = "input_arrays";
+static const char __pyx_k_is_coroutine[] = "_is_coroutine";
 static const char __pyx_k_missing_keys[] = "missing_keys";
 static const char __pyx_k_openInterest[] = "openInterest";
 static const char __pyx_k_outaroondown[] = "outaroondown";
@@ -2320,6 +3457,7 @@ static const char __pyx_k_CDLHANGINGMAN[] = "CDLHANGINGMAN";
 static const char __pyx_k_CDLHIKKAKEMOD[] = "CDLHIKKAKEMOD";
 static const char __pyx_k_Function_info[] = "Function.info";
 static const char __pyx_k_PANDAS_SERIES[] = "__PANDAS_SERIES";
+static const char __pyx_k_POLARS_SERIES[] = "__POLARS_SERIES";
 static const char __pyx_k_TA_CDL3INSIDE[] = "TA_CDL3INSIDE";
 static const char __pyx_k_TA_CDLHIKKAKE[] = "TA_CDLHIKKAKE";
 static const char __pyx_k_TA_CDLKICKING[] = "TA_CDLKICKING";
@@ -2330,11 +3468,14 @@ static const char __pyx_k_TA_HT_DCPHASE[] = "TA_HT_DCPHASE";
 static const char __pyx_k_TA_Initialize[] = "TA_Initialize";
 static const char __pyx_k_Unknown_Error[] = "Unknown Error";
 static const char __pyx_k_call_function[] = "__call_function";
+static const char __pyx_k_class_getitem[] = "__class_getitem__";
 static const char __pyx_k_default_value[] = "default_value";
 static const char __pyx_k_documentation[] = "documentation";
 static const char __pyx_k_function_name[] = "function_name";
 static const char __pyx_k_outmacdsignal[] = "outmacdsignal";
+static const char __pyx_k_outputs_valid[] = "outputs_valid";
 static const char __pyx_k_outquadrature[] = "outquadrature";
+static const char __pyx_k_stream_AVGDEV[] = "stream_AVGDEV";
 static const char __pyx_k_stream_BBANDS[] = "stream_BBANDS";
 static const char __pyx_k_stream_CORREL[] = "stream_CORREL";
 static const char __pyx_k_stream_MINMAX[] = "stream_MINMAX";
@@ -2354,7 +3495,6 @@ static const char __pyx_k_CDLMORNINGSTAR[] = "CDLMORNINGSTAR";
 static const char __pyx_k_CDLRICKSHAWMAN[] = "CDLRICKSHAWMAN";
 static const char __pyx_k_CDLSPINNINGTOP[] = "CDLSPINNINGTOP";
 static const char __pyx_k_Function___str[] = "Function.__str__";
-static const char __pyx_k_Function__info[] = "_Function__info";
 static const char __pyx_k_Function__name[] = "_Function__name";
 static const char __pyx_k_MA_Type___init[] = "MA_Type.__init__";
 static const char __pyx_k_ShadowVeryLong[] = "ShadowVeryLong";
@@ -2374,6 +3514,8 @@ static const char __pyx_k_function_flags[] = "function_flags";
 static const char __pyx_k_get_parameters[] = "get_parameters";
 static const char __pyx_k_input_arrays_2[] = "[input_arrays]";
 static const char __pyx_k_num_opt_inputs[] = "num_opt_inputs";
+static const char __pyx_k_outmaxidx_data[] = "outmaxidx_data";
+static const char __pyx_k_outminidx_data[] = "outminidx_data";
 static const char __pyx_k_set_parameters[] = "set_parameters";
 static const char __pyx_k_stream_CDLDOJI[] = "stream_CDLDOJI";
 static const char __pyx_k_stream_HT_SINE[] = "stream_HT_SINE";
@@ -2383,6 +3525,7 @@ static const char __pyx_k_stream_PLUS_DI[] = "stream_PLUS_DI";
 static const char __pyx_k_stream_PLUS_DM[] = "stream_PLUS_DM";
 static const char __pyx_k_stream_ROCR100[] = "stream_ROCR100";
 static const char __pyx_k_ta_getFuncInfo[] = "_ta_getFuncInfo";
+static const char __pyx_k_A_d_q_4z_q_aq_q[] = "\200A\360\n\000\t\017\210d\220(\230(\240%\240q\330\010\013\2104\210z\230\021\230%\230q\330\014\022\220$\220a\220q\330\010\017\210q";
 static const char __pyx_k_CDLADVANCEBLOCK[] = "CDLADVANCEBLOCK";
 static const char __pyx_k_CDLHOMINGPIGEON[] = "CDLHOMINGPIGEON";
 static const char __pyx_k_CDLLADDERBOTTOM[] = "CDLLADDERBOTTOM";
@@ -2391,6 +3534,7 @@ static const char __pyx_k_CDLUNIQUE3RIVER[] = "CDLUNIQUE3RIVER";
 static const char __pyx_k_Function___call[] = "Function.__call__";
 static const char __pyx_k_Function___init[] = "Function.__init__";
 static const char __pyx_k_Function___repr[] = "Function.__repr__";
+static const char __pyx_k_Function__local[] = "_Function__local";
 static const char __pyx_k_LINEARREG_ANGLE[] = "LINEARREG_ANGLE";
 static const char __pyx_k_LINEARREG_SLOPE[] = "LINEARREG_SLOPE";
 static const char __pyx_k_ShadowVeryShort[] = "ShadowVeryShort";
@@ -2404,7 +3548,9 @@ static const char __pyx_k_TA_HT_TRENDMODE[] = "TA_HT_TRENDMODE";
 static const char __pyx_k_TA_OUTPUT_FLAGS[] = "TA_OUTPUT_FLAGS";
 static const char __pyx_k_get_input_names[] = "get_input_names";
 static const char __pyx_k_offsetonreverse[] = "offsetonreverse";
+static const char __pyx_k_outinteger_data[] = "outinteger_data";
 static const char __pyx_k_set_input_names[] = "set_input_names";
+static const char __pyx_k_stream_ACCBANDS[] = "stream_ACCBANDS";
 static const char __pyx_k_stream_AROONOSC[] = "stream_AROONOSC";
 static const char __pyx_k_stream_AVGPRICE[] = "stream_AVGPRICE";
 static const char __pyx_k_stream_MAXINDEX[] = "stream_MAXINDEX";
@@ -2419,13 +3565,16 @@ static const char __pyx_k_stream_TYPPRICE[] = "stream_TYPPRICE";
 static const char __pyx_k_stream_WCLPRICE[] = "stream_WCLPRICE";
 static const char __pyx_k_ta_getFuncTable[] = "_ta_getFuncTable";
 static const char __pyx_k_talib__func_pxi[] = "talib/_func.pxi";
+static const char __pyx_k_A_A_AQ_6_A_E_A_q[] = "\200A\360\010\000\t\021\220\004\220A\330\010\020\220\005\220[\240\001\240\033\250A\250Q\330\010\013\2106\220\023\220A\330\014\024\220E\230\033\240A\240[\260\001\260\021\330\010\017\210q";
 static const char __pyx_k_CDL3STARSINSOUTH[] = "CDL3STARSINSOUTH";
 static const char __pyx_k_CDLABANDONEDBABY[] = "CDLABANDONEDBABY";
 static const char __pyx_k_CDLCOUNTERATTACK[] = "CDLCOUNTERATTACK";
 static const char __pyx_k_CDLDRAGONFLYDOJI[] = "CDLDRAGONFLYDOJI";
 static const char __pyx_k_CDLSTICKSANDWICH[] = "CDLSTICKSANDWICH";
+static const char __pyx_k_Function___local[] = "Function.__local";
 static const char __pyx_k_Function_outputs[] = "Function.outputs";
 static const char __pyx_k_PANDAS_DATAFRAME[] = "__PANDAS_DATAFRAME";
+static const char __pyx_k_POLARS_DATAFRAME[] = "__POLARS_DATAFRAME";
 static const char __pyx_k_TA_CDLHANGINGMAN[] = "TA_CDLHANGINGMAN";
 static const char __pyx_k_TA_CDLHIKKAKEMOD[] = "TA_CDLHIKKAKEMOD";
 static const char __pyx_k_TA_FuncTableFree[] = "TA_FuncTableFree";
@@ -2444,6 +3593,7 @@ static const char __pyx_k_stream_CDLONNECK[] = "stream_CDLONNECK";
 static const char __pyx_k_stream_CDLTAKURI[] = "stream_CDLTAKURI";
 static const char __pyx_k_stream_HT_PHASOR[] = "stream_HT_PHASOR";
 static const char __pyx_k_stream_LINEARREG[] = "stream_LINEARREG";
+static const char __pyx_k_ta_check_success[] = "_ta_check_success";
 static const char __pyx_k_ta_func_unst_ids[] = "_ta_func_unst_ids";
 static const char __pyx_k_ta_getGroupTable[] = "_ta_getGroupTable";
 static const char __pyx_k_AllCandleSettings[] = "AllCandleSettings";
@@ -2455,7 +3605,6 @@ static const char __pyx_k_CDLLONGLEGGEDDOJI[] = "CDLLONGLEGGEDDOJI";
 static const char __pyx_k_CDLSTALLEDPATTERN[] = "CDLSTALLEDPATTERN";
 static const char __pyx_k_CandleSettingType[] = "CandleSettingType";
 static const char __pyx_k_Function__namestr[] = "_Function__namestr";
-static const char __pyx_k_Function__outputs[] = "_Function__outputs";
 static const char __pyx_k_Function_lookback[] = "Function.lookback";
 static const char __pyx_k_MA_Type___getitem[] = "MA_Type.__getitem__";
 static const char __pyx_k_TA_CDL3BLACKCROWS[] = "TA_CDL3BLACKCROWS";
@@ -2481,6 +3630,7 @@ static const char __pyx_k_stream_CDLTRISTAR[] = "stream_CDLTRISTAR";
 static const char __pyx_k_stream_HT_DCPHASE[] = "stream_HT_DCPHASE";
 static const char __pyx_k_talib__common_pxi[] = "talib/_common.pxi";
 static const char __pyx_k_talib__stream_pxi[] = "talib/_stream.pxi";
+static const char __pyx_k_A_A_k_M_a_q_T_7q_q[] = "\200A\360\010\000\t\021\220\004\220A\330\010\016\210k\230\021\330\010\014\210M\230\025\230a\330\014\017\210q\220\r\230T\320!7\260q\270\001\330\010\017\210q";
 static const char __pyx_k_CDLCLOSINGMARUBOZU[] = "CDLCLOSINGMARUBOZU";
 static const char __pyx_k_CDLEVENINGDOJISTAR[] = "CDLEVENINGDOJISTAR";
 static const char __pyx_k_CDLIDENTICAL3CROWS[] = "CDLIDENTICAL3CROWS";
@@ -2491,6 +3641,7 @@ static const char __pyx_k_CDLUPSIDEGAP2CROWS[] = "CDLUPSIDEGAP2CROWS";
 static const char __pyx_k_Function___unicode[] = "Function.__unicode__";
 static const char __pyx_k_INPUT_ARRAYS_TYPES[] = "__INPUT_ARRAYS_TYPES";
 static const char __pyx_k_Output_can_be_zero[] = "Output can be zero";
+static const char __pyx_k_Q_V1E_q_WAQ_Q_aq_1[] = "\200\001\360\n\000\005\026\220Q\320\026.\320.@\300\001\300\027\310\001\310\021\330\004\020\220\001\330\004\010\210\005\210V\2201\220E\230\021\330\010\021\220\027\230\001\230\026\230q\240\005\240W\250A\250Q\330\004\025\220Q\320\026-\320->\270a\270q\330\004\013\2101";
 static const char __pyx_k_TA_CDLADVANCEBLOCK[] = "TA_CDLADVANCEBLOCK";
 static const char __pyx_k_TA_CDLHOMINGPIGEON[] = "TA_CDLHOMINGPIGEON";
 static const char __pyx_k_TA_CDLLADDERBOTTOM[] = "TA_CDLLADDERBOTTOM";
@@ -2500,8 +3651,8 @@ static const char __pyx_k_TA_GroupTableAlloc[] = "TA_GroupTableAlloc";
 static const char __pyx_k_TA_LINEARREG_ANGLE[] = "TA_LINEARREG_ANGLE";
 static const char __pyx_k_TA_LINEARREG_SLOPE[] = "TA_LINEARREG_SLOPE";
 static const char __pyx_k_TA_ParamHolderFree[] = "TA_ParamHolderFree";
+static const char __pyx_k_asyncio_coroutines[] = "asyncio.coroutines";
 static const char __pyx_k_cline_in_traceback[] = "cline_in_traceback";
-static const char __pyx_k_inputs_are_all_NaN[] = "inputs are all NaN";
 static const char __pyx_k_stream_CDL3OUTSIDE[] = "stream_CDL3OUTSIDE";
 static const char __pyx_k_stream_CDLBELTHOLD[] = "stream_CDLBELTHOLD";
 static const char __pyx_k_stream_CDLDOJISTAR[] = "stream_CDLDOJISTAR";
@@ -2511,11 +3662,14 @@ static const char __pyx_k_stream_CDLMARUBOZU[] = "stream_CDLMARUBOZU";
 static const char __pyx_k_stream_CDLPIERCING[] = "stream_CDLPIERCING";
 static const char __pyx_k_stream_HT_DCPERIOD[] = "stream_HT_DCPERIOD";
 static const char __pyx_k_stream_MINMAXINDEX[] = "stream_MINMAXINDEX";
+static const char __pyx_k_A_A_gQ_5_q_5_V1_5_U[] = "\200A\360\010\000\t\021\220\004\220A\330\010\013\320\013\036\230g\240Q\330\014\020\220\n\230!\2305\240\017\250q\330\014\023\2205\230\r\240V\2501\340\014\023\2205\230\r\240U\250!";
 static const char __pyx_k_CDLCONCEALBABYSWALL[] = "CDLCONCEALBABYSWALL";
 static const char __pyx_k_CDLGAPSIDESIDEWHITE[] = "CDLGAPSIDESIDEWHITE";
 static const char __pyx_k_CDLRISEFALL3METHODS[] = "CDLRISEFALL3METHODS";
 static const char __pyx_k_CDLXSIDEGAP3METHODS[] = "CDLXSIDEGAP3METHODS";
+static const char __pyx_k_Function__localdata[] = "_Function__localdata";
 static const char __pyx_k_LINEARREG_INTERCEPT[] = "LINEARREG_INTERCEPT";
+static const char __pyx_k_ModuleNotFoundError[] = "ModuleNotFoundError";
 static const char __pyx_k_TA_CDL3STARSINSOUTH[] = "TA_CDL3STARSINSOUTH";
 static const char __pyx_k_TA_CDLABANDONEDBABY[] = "TA_CDLABANDONEDBABY";
 static const char __pyx_k_TA_CDLCOUNTERATTACK[] = "TA_CDLCOUNTERATTACK";
@@ -2533,7 +3687,8 @@ static const char __pyx_k_stream_CDLTHRUSTING[] = "stream_CDLTHRUSTING";
 static const char __pyx_k_stream_HT_TRENDLINE[] = "stream_HT_TRENDLINE";
 static const char __pyx_k_stream_HT_TRENDMODE[] = "stream_HT_TRENDMODE";
 static const char __pyx_k_talib__abstract_pxi[] = "talib/_abstract.pxi";
-static const char __pyx_k_Function__opt_inputs[] = "_Function__opt_inputs";
+static const char __pyx_k_A_A_L_6_Qk_A_a_QnA_a[] = "\200A\360\010\000\t\021\220\004\220A\330\010\014\210L\320\030(\250\013\2606\270\021\330\014\021\220\034\230Q\230k\250\021\320*<\270A\330\014\021\220\025\220a\220~\240Q\240n\260A\330\010\r\320\r\036\230a";
+static const char __pyx_k_A_A_k_N_q_q_e_q_1A_q[] = "\200A\360\n\000\t\021\220\004\220A\330\010\016\210k\230\021\330\010\014\210N\230%\230q\330\014\017\210q\220\016\230e\240<\250q\260\013\2701\270A\330\010\017\210q";
 static const char __pyx_k_TA_CDL3WHITESOLDIERS[] = "TA_CDL3WHITESOLDIERS";
 static const char __pyx_k_TA_CDLDARKCLOUDCOVER[] = "TA_CDLDARKCLOUDCOVER";
 static const char __pyx_k_TA_CDLGRAVESTONEDOJI[] = "TA_CDLGRAVESTONEDOJI";
@@ -2548,10 +3703,8 @@ static const char __pyx_k_stream_CDLHANGINGMAN[] = "stream_CDLHANGINGMAN";
 static const char __pyx_k_stream_CDLHIKKAKEMOD[] = "stream_CDLHIKKAKEMOD";
 static const char __pyx_k_ta_get_compatibility[] = "_ta_get_compatibility";
 static const char __pyx_k_ta_set_compatibility[] = "_ta_set_compatibility";
-static const char __pyx_k_Function__input_names[] = "_Function__input_names";
 static const char __pyx_k_Function_output_flags[] = "Function.output_flags";
 static const char __pyx_k_Function_output_names[] = "Function.output_names";
-static const char __pyx_k_INPUT_ARRAYS_DEFAULTS[] = "__INPUT_ARRAYS_DEFAULTS";
 static const char __pyx_k_Output_is_over_volume[] = "Output is over volume";
 static const char __pyx_k_Simple_Moving_Average[] = "Simple Moving Average";
 static const char __pyx_k_TA_CDLCLOSINGMARUBOZU[] = "TA_CDLCLOSINGMARUBOZU";
@@ -2572,9 +3725,10 @@ static const char __pyx_k_stream_CDLMATCHINGLOW[] = "stream_CDLMATCHINGLOW";
 static const char __pyx_k_stream_CDLMORNINGSTAR[] = "stream_CDLMORNINGSTAR";
 static const char __pyx_k_stream_CDLRICKSHAWMAN[] = "stream_CDLRICKSHAWMAN";
 static const char __pyx_k_stream_CDLSPINNINGTOP[] = "stream_CDLSPINNINGTOP";
-static const char __pyx_k_Function__input_arrays[] = "_Function__input_arrays";
+static const char __pyx_k_A_A_6_6_6_7_7_81_7_7_5[] = "\200A\330\010\014\210A\330\014\023\2206\230\021\330\014\023\2206\230\021\330\014\023\2206\230\021\330\014\023\2207\230!\330\014\023\2207\230!\330\014\023\2208\2301\330\014\023\2207\230!\330\014\023\2207\230!\330\014\023\2205\230\001";
 static const char __pyx_k_Output_can_be_negative[] = "Output can be negative";
 static const char __pyx_k_Output_can_be_positive[] = "Output can be positive";
+static const char __pyx_k_Q_B_1A_Q_V1E_gQfAU_Q_1[] = "\200\001\360\n\000\005\026\220Q\320\026/\320/B\300!\3001\300A\330\004\r\210Q\330\004\010\210\005\210V\2201\220E\230\021\330\010\016\210g\220Q\220f\230A\230U\240'\250\021\250!\330\004\025\220Q\320\026.\320.@\300\001\300\021\330\004\013\2101";
 static const char __pyx_k_TA_CDLCONCEALBABYSWALL[] = "TA_CDLCONCEALBABYSWALL";
 static const char __pyx_k_TA_CDLGAPSIDESIDEWHITE[] = "TA_CDLGAPSIDESIDEWHITE";
 static const char __pyx_k_TA_CDLRISEFALL3METHODS[] = "TA_CDLRISEFALL3METHODS";
@@ -2592,7 +3746,6 @@ static const char __pyx_k_ta_get_unstable_period[] = "_ta_get_unstable_period";
 static const char __pyx_k_ta_set_candle_settings[] = "_ta_set_candle_settings";
 static const char __pyx_k_ta_set_unstable_period[] = "_ta_set_unstable_period";
 static const char __pyx_k_Function__call_function[] = "_Function__call_function";
-static const char __pyx_k_Function__outputs_valid[] = "_Function__outputs_valid";
 static const char __pyx_k_Function_function_flags[] = "Function.function_flags";
 static const char __pyx_k_Function_get_parameters[] = "Function.get_parameters";
 static const char __pyx_k_Function_set_parameters[] = "Function.set_parameters";
@@ -2604,13 +3757,15 @@ static const char __pyx_k_stream_CDLABANDONEDBABY[] = "stream_CDLABANDONEDBABY";
 static const char __pyx_k_stream_CDLCOUNTERATTACK[] = "stream_CDLCOUNTERATTACK";
 static const char __pyx_k_stream_CDLDRAGONFLYDOJI[] = "stream_CDLDRAGONFLYDOJI";
 static const char __pyx_k_stream_CDLSTICKSANDWICH[] = "stream_CDLSTICKSANDWICH";
+static const char __pyx_k_A_Jm6_M_Q_Jiq_A_O9F_b_O1[] = "\200A\340\010\014\210J\220m\2406\250\021\330\010\014\210M\230\024\230Q\330\010\014\210J\220i\230q\240\004\240A\360\006\000\t\r\210O\2309\240F\250!\360\006\000\t\r\320\014\036\230b\240\010\250\001\330\010\014\210O\2301";
 static const char __pyx_k_Bad_Object_TA_BAD_OBJECT[] = "Bad Object (TA_BAD_OBJECT)";
 static const char __pyx_k_Function___call_function[] = "Function.__call_function";
 static const char __pyx_k_Function_get_input_names[] = "Function.get_input_names";
 static const char __pyx_k_Function_set_input_names[] = "Function.set_input_names";
 static const char __pyx_k_TA_GetInputParameterInfo[] = "TA_GetInputParameterInfo";
-static const char __pyx_k_initialize_function_info[] = "__initialize_function_info";
 static const char __pyx_k_input_price_series_names[] = "input_price_series_names";
+static const char __pyx_k_no_existing_input_arrays[] = "no_existing_input_arrays";
+static const char __pyx_k_price_series_name_values[] = "price_series_name_values";
 static const char __pyx_k_stream_CDL3WHITESOLDIERS[] = "stream_CDL3WHITESOLDIERS";
 static const char __pyx_k_stream_CDLDARKCLOUDCOVER[] = "stream_CDLDARKCLOUDCOVER";
 static const char __pyx_k_stream_CDLGRAVESTONEDOJI[] = "stream_CDLGRAVESTONEDOJI";
@@ -2630,6 +3785,7 @@ static const char __pyx_k_stream_CDLMORNINGDOJISTAR[] = "stream_CDLMORNINGDOJIST
 static const char __pyx_k_stream_CDLSEPARATINGLINES[] = "stream_CDLSEPARATINGLINES";
 static const char __pyx_k_stream_CDLUPSIDEGAP2CROWS[] = "stream_CDLUPSIDEGAP2CROWS";
 static const char __pyx_k_ta_getOutputParameterInfo[] = "_ta_getOutputParameterInfo";
+static const char __pyx_k_A_A_1_N_q_5_A_z_HA_G1A_q_q[] = "\200A\330\010\020\220\004\220A\330\010#\2401\330\010\014\210N\230%\230q\330\014\033\2305\240\014\250A\250[\270\001\270\021\330\014\017\210z\230\021\230.\250\001\330\020\024\220H\230A\330\024,\250G\2601\260A\340\020(\250\007\250q\260\001\330\010\017\210q";
 static const char __pyx_k_Bad_Parameter_TA_BAD_PARAM[] = "Bad Parameter (TA_BAD_PARAM)";
 static const char __pyx_k_Exponential_Moving_Average[] = "Exponential Moving Average";
 static const char __pyx_k_Function_set_function_args[] = "Function.set_function_args";
@@ -2642,37 +3798,185 @@ static const char __pyx_k_stream_CDLRISEFALL3METHODS[] = "stream_CDLRISEFALL3MET
 static const char __pyx_k_stream_CDLXSIDEGAP3METHODS[] = "stream_CDLXSIDEGAP3METHODS";
 static const char __pyx_k_stream_LINEARREG_INTERCEPT[] = "stream_LINEARREG_INTERCEPT";
 static const char __pyx_k_INPUT_PRICE_SERIES_DEFAULTS[] = "__INPUT_PRICE_SERIES_DEFAULTS";
+static const char __pyx_k_Invalid_parameter_value_for[] = "Invalid parameter value for ";
 static const char __pyx_k_TA_GetOptInputParameterInfo[] = "TA_GetOptInputParameterInfo";
-static const char __pyx_k_ndarray_is_not_C_contiguous[] = "ndarray is not C contiguous";
 static const char __pyx_k_ta_getOptInputParameterInfo[] = "_ta_getOptInputParameterInfo";
 static const char __pyx_k_MESA_Adaptive_Moving_Average[] = "MESA Adaptive Moving Average";
+static const char __pyx_k_Q_A_1_G9JfA_t_1G1_q_1_a_U_4q[] = "\320\004\035\230Q\360\010\000\t\021\220\004\220A\330\010\025\220[\240\003\2401\330\010\022\220'\230\021\230!\330\010\014\210G\2209\230J\240f\250A\330\014\017\210t\320\023+\2501\250G\2601\330\020\025\220[\240\001\240\026\240q\250\013\2601\330\010\r\320\r\036\230a\330\010\r\210U\220!\320\023#\2404\240q";
 static const char __pyx_k_Unknown_Error_TA_UNKNOWN_ERR[] = "Unknown Error (TA_UNKNOWN_ERR)";
+static const char __pyx_k_aq_Q_T_q_a_fHBd_a_kkllm_Qj_1[] = "\200\001\360&\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\r\210T\220\026\220q\230\001\330\004\016\210a\330\004\021\220\027\230\002\230&\240\010\250\002\250$\250f\260H\270B\270d\300,\310a\310|\320[\\\320\\k\320kl\320lm\330\004\025\220Q\220j\240\001\330\004\013\2101";
 static const char __pyx_k_Allocation_Error_TA_ALLOC_ERR[] = "Allocation Error (TA_ALLOC_ERR)";
 static const char __pyx_k_Function__get_opt_input_value[] = "_Function__get_opt_input_value";
+static const char __pyx_k_aq_Qa_Kq_6_a_8_T_3hjX_U_7_A_w[] = "\200\001\340_`\360.\000\005\014\210;\220a\220q\330\004\n\210+\220Q\220a\330\004\014\210K\220q\230\001\330\004\r\210]\230!\2306\240\025\240a\330\004\r\210]\230!\2308\240:\250T\260\030\270\032\3003\300h\310j\320X]\320]^\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\0330\260\002\260!\330\004\027\320\027(\250\001\250\030\260\021\330\004\030\320\030)\250\021\250(\260!\330\004\027\320\027(\250\001\250\030\260\021\330\004\021\220\034\230R\230t\2409\250K\260t\2706\300\021\300)\310;\320VY\320Y_\320_`\320`i\320it\320ty\320y\177\360\000\000@\002A\002\360\000\000A\002J\002\360\000\000J\002W\002\360\000\000W\002X\002\360\000\000X\002d\002\360\000\000d\002e\002\360\000\000e\002t\002\360\000\000t\002\177\002\360\000\000\177\002O\003\360\000\000O\003U\003\360\000\000U\003V\003\360\000\000V\003a\003\360\000\000a\003l\003\360\000\000l\003}\003\360\000\000}\003C\004\360\000\000C\004D\004\360\000\000D\004O\004\360\000\000O\004Z\004\360\000\000Z\004j\004\360\000\000j\004p\004\360\000\000p\004q\004\360\000\000q\004r\004\330\004\025\220Q\220o\240Q\330\004\013\320\013\036\320\0362\260!";
+static const char __pyx_k_01_aq_T_q_8_T_U_7_A_we_7r_q_Bd[] = "\200\001\34001\360&\000\005\014\210;\220a\220q\330\004\r\210T\220\026\220q\230\001\330\004\r\210]\230!\2308\240:\250T\260\021\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\0337\260r\270\021\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\320\021$\240B\240d\250)\260;\270d\300&\310\001\310\031\320R_\320_`\320`l\320lm\320m|\360\000\000}\001H\002\360\000\000H\002O\002\360\000\000O\002U\002\360\000\000U\002V\002\360\000\000V\002W\002\330\004\025\220Q\320\026,\250A\330\004\013\2101";
+static const char __pyx_k_1_aq_T_q_8_T_U_7_A_we_M_q_r_Yk[] = "\200\001\340#;\2701\360(\000\005\014\210;\220a\220q\330\004\r\210T\220\026\220q\230\001\330\004\r\210]\230!\2308\240:\250T\260\021\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\230?\250\"\250M\270\021\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\026\220r\230\024\230Y\240k\260\024\260V\2701\270I\300]\320R[\320[\\\320\\h\320hi\320ix\360\000\000y\001D\002\360\000\000D\002K\002\360\000\000K\002Q\002\360\000\000Q\002R\002\360\000\000R\002S\002\330\004\025\220Q\220i\230q\330\004\013\2101";
+static const char __pyx_k_314DAQ_Q_a_4q_a_Qd_c_a_Qd_s_4q[] = "\200\001\360\014\000\005\022\220\037\240\001\320!3\2601\3204D\300A\300Q\330\004\025\220Q\320\026(\250\001\340\004\005\330\010\020\220\t\230\021\230$\230a\330\010\021\220\031\230!\2304\230q\330\010\030\230\t\240\021\240$\240a\330\010\032\230+\240Q\240d\250(\260!\330\010\026\220c\230\021\230$\230a\330\010\032\230#\230Q\230d\240!\330\010\027\220s\230!\2304\230q";
+static const char __pyx_k_BC_Kq_Kq_7_8_U_E_U_7_A_we_Ba_q[] = "\200\001\340BC\360(\000\005\r\210K\220q\230\001\330\004\014\210K\220q\230\001\330\004\r\210]\230!\2307\240!\330\004\r\210]\230!\2308\240:\250U\260(\270*\300E\310\021\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033,\250B\250a\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\030\230\022\2304\230y\250\013\2605\270\006\270a\270y\310\013\320SX\320X^\320^_\320_h\320hu\320uv\360\000\000w\001C\002\360\000\000C\002D\002\360\000\000D\002S\002\360\000\000S\002^\002\360\000\000^\002e\002\360\000\000e\002k\002\360\000\000k\002l\002\360\000\000l\002m\002\330\004\025\220Q\220k\240\021\330\004\013\2101";
+static const char __pyx_k_BC_aq_Qa_6_8_T_3a_U_7_A_we_r_q[] = "\200\001\340BC\360&\000\005\014\210;\220a\220q\330\004\n\210+\220Q\220a\330\004\r\210]\230!\2306\240\021\330\004\r\210]\230!\2308\240:\250T\260\030\270\032\3003\300a\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033/\250r\260\021\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\033\230B\230d\240)\250;\260d\270&\300\001\300\031\310+\320UX\320X^\320^_\320_h\320hu\320uv\360\000\000w\001C\002\360\000\000C\002D\002\360\000\000D\002S\002\360\000\000S\002^\002\360\000\000^\002e\002\360\000\000e\002k\002\360\000\000k\002l\002\360\000\000l\002m\002\330\004\025\220Q\220n\240A\330\004\013\2101";
+static const char __pyx_k_C1_aq_Q_T_q_a_fHBd_m_ccddppq_r[] = "\200\001\340+C\3001\360(\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\r\210T\220\026\220q\230\001\330\004\016\210a\330\004\021\220\027\230\002\230&\240\010\250\002\250$\250f\260H\270B\270d\300,\310m\320[c\320cd\320dp\320pq\360\000\000r\001A\002\360\000\000A\002B\002\360\000\000B\002C\002\330\004\025\220Q\220j\240\001\330\004\013\2101";
+static const char __pyx_k_CD_aq_Qa_6_8_T_3a_U_7_A_we_0_q[] = "\200\001\340CD\360&\000\005\014\210;\220a\220q\330\004\n\210+\220Q\220a\330\004\r\210]\230!\2306\240\021\330\004\r\210]\230!\2308\240:\250T\260\030\270\032\3003\300a\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\0330\260\002\260!\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\034\230R\230t\2409\250K\260t\2706\300\021\300)\310;\320VY\320Y_\320_`\320`i\320iv\320vw\360\000\000x\001D\002\360\000\000D\002E\002\360\000\000E\002T\002\360\000\000T\002_\002\360\000\000_\002f\002\360\000\000f\002l\002\360\000\000l\002m\002\360\000\000m\002n\002\330\004\025\220Q\220o\240Q\330\004\013\2101";
+static const char __pyx_k_D_E_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA[] = "\200\001\360\004\000D\002E\002\360,\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\013\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\n\210+\220Q\220a\330\004\017\210y\230\003\2301\330\004\014\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\r\210]\230!\2306\240\026\240u\250A\330\004\021\220\021\330\004\021\220\036\230r\240\026\240x\250r\260\024\260V\2708\3002\300T\310\034\320Ua\320al\320ly\360\000\000z\001H\002\360\000\000H\002I\002\360\000\000I\002U\002\360\000\000U\002V\002\360\000\000V\002e\002\360\000\000e\002f\002\360\000\000f\002g\002\330\004\025\220Q\320\026'\240q\330\004\013\2101";
 static const char __pyx_k_Function___get_opt_input_value[] = "Function.__get_opt_input_value";
+static const char __pyx_k_H_I_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA[] = "\200\001\360\004\000H\002I\002\360,\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\013\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\n\210+\220Q\220a\330\004\017\210y\230\003\2301\330\004\014\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\r\210]\230!\2306\240\026\240u\250A\330\004\021\220\021\330\004\021\320\021#\2402\240V\2508\2602\260T\270\026\270x\300r\310\024\310\\\320Ye\320ep\320p}\360\000\000~\001L\002\360\000\000L\002M\002\360\000\000M\002Y\002\360\000\000Y\002Z\002\360\000\000Z\002i\002\360\000\000i\002j\002\360\000\000j\002k\002\330\004\025\220Q\320\026+\2501\330\004\013\2101";
+static const char __pyx_k_Hb_c_B_B_f_f_F_F_i_i_N_N_o_o_p[] = "\200\001\340Hb\360\000\000c\001B\002\360\000\000B\002f\002\360\000\000f\002F\003\360\000\000F\003i\003\360\000\000i\003N\004\360\000\000N\004o\004\360\000\000o\004p\004\3606\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\n\210+\220Q\220a\330\004\017\210y\230\003\2301\330\004\r\210]\230!\2306\240\021\330\004\016\210a\330\004\021\220\032\2302\230V\2408\2502\250T\260\026\260x\270r\300\024\300\\\320Q\\\320\\i\320i{\360\000\000|\001S\002\360\000\000S\002f\002\360\000\000f\002|\002\360\000\000|\002T\003\360\000\000T\003h\003\360\000\000h\003\177\003\360\000\000\177\003@\004\360\000\000@\004L\004\360\000\000L\004M\004\360\000\000M\004\\\004\360\000\000\\\004]\004\360\000\000]\004^\004\330\004\025\220Q\220m\2401\330\004\013\2101";
+static const char __pyx_k_J_K_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA[] = "\200\001\360\004\000J\002K\002\360,\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\013\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\n\210+\220Q\220a\330\004\017\210y\230\003\2301\330\004\014\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\r\210]\230!\2306\240\026\240u\250A\330\004\021\220\021\330\004\021\320\021%\240R\240v\250X\260R\260t\2706\300\030\310\022\3104\310|\320[g\320gr\320r\177\360\000\000@\002N\002\360\000\000N\002O\002\360\000\000O\002[\002\360\000\000[\002\\\002\360\000\000\\\002k\002\360\000\000k\002l\002\360\000\000l\002m\002\330\004\025\220Q\320\026-\250Q\330\004\013\2101";
+static const char __pyx_k_K_L_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA[] = "\200\001\360\004\000K\002L\002\360,\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\013\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\n\210+\220Q\220a\330\004\017\210y\230\003\2301\330\004\014\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\r\210]\230!\2306\240\026\240u\250A\330\004\021\220\021\330\004\021\320\021&\240b\250\006\250h\260b\270\004\270F\300(\310\"\310D\320P\\\320\\h\320hs\360\000\000t\001A\002\360\000\000A\002O\002\360\000\000O\002P\002\360\000\000P\002\\\002\360\000\000\\\002]\002\360\000\000]\002l\002\360\000\000l\002m\002\360\000\000m\002n\002\330\004\025\220Q\320\026.\250a\330\004\013\2101";
+static const char __pyx_k_Kq_q_Kq_q_7_a_6_4vXRt_P_jjkkzz[] = "\200\001\360*\000\005\r\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\014\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\r\210]\230!\2307\240!\330\004\016\210a\330\004\021\220\030\230\022\2306\240\030\250\022\2504\250v\260X\270R\270t\300=\320P]\320]^\320^j\320jk\320kz\320z{\320{|\330\004\025\220Q\220k\240\021\330\004\013\2101";
+static const char __pyx_k_Kq_q_Kq_q_7_a_fHBd_iijjyyzz_Qj[] = "\200\001\360*\000\005\r\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\014\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\r\210]\230!\2307\240!\330\004\016\210a\330\004\021\220\027\230\002\230&\240\010\250\002\250$\250f\260H\270B\270d\300-\310}\320\\]\320]i\320ij\320jy\320yz\320z{\330\004\025\220Q\220j\240\001\330\004\013\2101";
+static const char __pyx_k_L_M_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA[] = "\200\001\360\004\000L\002M\002\360,\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\013\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\n\210+\220Q\220a\330\004\017\210y\230\003\2301\330\004\014\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\r\210]\230!\2306\240\026\240u\250A\330\004\021\220\021\330\004\021\320\021'\240r\250\026\250x\260r\270\024\270V\3008\3102\310T\320Q]\320]i\320it\360\000\000u\001B\002\360\000\000B\002P\002\360\000\000P\002Q\002\360\000\000Q\002]\002\360\000\000]\002^\002\360\000\000^\002m\002\360\000\000m\002n\002\360\000\000n\002o\002\330\004\025\220Q\320\026/\250q\330\004\013\2101";
 static const char __pyx_k_Not_Supported_TA_NOT_SUPPORTED[] = "Not Supported (TA_NOT_SUPPORTED)";
+static const char __pyx_k_Q_AQQVVWWX_Q_5Q_9AT_4q_1JfA_Cq[] = "\200\001\360\014\000\005\022\320\021-\250Q\320.@\300\001\320AQ\320QV\320VW\320WX\330\004\025\220Q\320\0265\260Q\340\004\013\2109\220A\220T\230\021\330\004\013\2104\210q\220\003\2201\220J\230f\240A\330\004\024\220C\220q\230\004\320\034.\250d\260&\270\002\270'\300\024\300Q\340\004\005\330\010\020\220\001\330\010\030\230\t\240\021\240$\240a\330\010\020\220\004\220A\330\010\020\220\t\230\021\230$\230a\330\010\031\230\021\330\010\021\220\021";
 static const char __pyx_k_Values_represent_a_lower_limit[] = "Values represent a lower limit";
+static const char __pyx_k_YZ_aq_Qa_Kq_6_a_8_T_3hjX_U_7_A[] = "\200\001\340YZ\360&\000\005\014\210;\220a\220q\330\004\n\210+\220Q\220a\330\004\014\210K\220q\230\001\330\004\r\210]\230!\2306\240\025\240a\330\004\r\210]\230!\2308\240:\250T\260\030\270\032\3003\300h\310j\320X]\320]^\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\230?\250\"\250A\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\026\220r\230\024\230Y\240k\260\024\260V\2701\270I\300[\320PS\320SY\320YZ\320Zc\320cn\320ns\320sy\320yz\360\000\000{\001D\002\360\000\000D\002Q\002\360\000\000Q\002R\002\360\000\000R\002^\002\360\000\000^\002_\002\360\000\000_\002n\002\360\000\000n\002y\002\360\000\000y\002@\003\360\000\000@\003F\003\360\000\000F\003G\003\360\000\000G\003H\003\330\004\025\220Q\220i\230q\330\004\013\2101";
+static const char __pyx_k_ab_aq_Q_Qa_y_1_Kq_q_6_a_a_fHBd[] = "\200\001\340ab\360*\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\n\210+\220Q\220a\330\004\017\210y\230\003\2301\330\004\014\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\r\210]\230!\2306\240\025\240a\330\004\016\210a\330\004\021\220\027\230\002\230&\240\010\250\002\250$\250f\260H\270B\270d\300,\310k\320Yf\320fs\320st\360\000\000u\001A\002\360\000\000A\002B\002\360\000\000B\002Q\002\360\000\000Q\002R\002\360\000\000R\002S\002\330\004\025\220Q\220j\240\001\330\004\013\2101";
+static const char __pyx_k_aq_Q_Qa_y_1_Kq_q_6_6_gQ_a_fHBd[] = "\200\001\340~\177\360,\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\n\210+\220Q\220a\330\004\017\210y\230\003\2301\330\004\014\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\r\210[\230\001\230\021\330\004\022\220)\2306\240\021\330\004\r\210]\230!\2306\240\025\240g\250Q\330\004\016\210a\330\004\021\220\027\230\002\230&\240\010\250\002\250$\250f\260H\270B\270d\300,\310k\320Yf\320ft\360\000\000u\001B\002\360\000\000B\002C\002\360\000\000C\002O\002\360\000\000O\002P\002\360\000\000P\002_\002\360\000\000_\002`\002\360\000\000`\002a\002\330\004\025\220Q\220j\240\001\330\004\013\2101";
+static const char __pyx_k_aq_Q_Qa_y_1_Kq_q_6_6_gQ_a_r_xr[] = "\200\001\360,\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\n\210+\220Q\220a\330\004\017\210y\230\003\2301\330\004\014\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\r\210[\230\001\230\021\330\004\022\220)\2306\240\021\330\004\r\210]\230!\2306\240\025\240g\250Q\330\004\016\210a\330\004\021\220\026\220r\230\026\230x\240r\250\024\250V\2608\2702\270T\300\034\310[\320Xe\320es\320st\360\000\000u\001A\002\360\000\000A\002B\002\360\000\000B\002Q\002\360\000\000Q\002R\002\360\000\000R\002S\002\330\004\025\220Q\220i\230q\330\004\013\2101";
+static const char __pyx_k_aq_Q_T_q_Q_Q_2V82T_xr_Q___kkll[] = "\200\001\340./\360*\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\r\210T\220\026\220q\230\001\330\004\r\210Q\330\004\r\210Q\330\004\021\220\032\2302\230V\2408\2502\250T\260\026\260x\270r\300\024\300\\\320Q^\320^_\320_k\320kl\320l{\320{|\360\000\000}\001F\002\360\000\000F\002G\002\360\000\000G\002H\002\330\004\025\220Q\220m\2401\330\004\013\2109\220A";
+static const char __pyx_k_aq_Q_T_q_a_6_4vXRt_iijjyyzz_Qk[] = "\200\001\340,-\360&\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\r\210T\220\026\220q\230\001\330\004\016\210a\330\004\021\220\030\230\022\2306\240\030\250\022\2504\250v\260X\270R\270t\300<\310}\320\\]\320]i\320ij\320jy\320yz\320z{\330\004\025\220Q\220k\240\021\330\004\013\2101";
+static const char __pyx_k_aq_Q_T_q_a_6_4vXRt_qP_llmmn_Qk[] = "\200\001\360&\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\r\210T\220\026\220q\230\001\330\004\016\210a\330\004\021\220\030\230\022\2306\240\030\250\022\2504\250v\260X\270R\270t\300<\310q\320P\\\320\\]\320]l\320lm\320mn\330\004\025\220Q\220k\240\021\330\004\013\2101";
+static const char __pyx_k_aq_Q_T_q_a_BfHBd_lRSS___ooppzz[] = "\200\001\360*\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\r\210T\220\026\220q\230\001\330\004\016\210a\330\004\022\220!\330\004\021\220\033\230B\230f\240H\250B\250d\260&\270\010\300\002\300$\300l\320RS\320S_\320_`\320`o\320op\320pz\320z{\320{|\330\004\025\220Q\220n\240A\330\004\013\210:\220Q";
+static const char __pyx_k_aq_Q_T_q_a_F_D_hb_LP_jjkkzz_Ql[] = "\200\001\340-.\360&\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\r\210T\220\026\220q\230\001\330\004\016\210a\330\004\021\220\031\230\"\230F\240(\250\"\250D\260\006\260h\270b\300\004\300L\320P]\320]^\320^j\320jk\320kz\320z{\320{|\330\004\025\220Q\220l\240!\330\004\013\2101";
+static const char __pyx_k_aq_Q_T_q_a_fHBdR_kkllxxy_z_I_I[] = "\200\001\340;<\360&\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\r\210T\220\026\220q\230\001\330\004\016\210a\330\004\021\320\021(\250\002\250&\260\010\270\002\270$\270f\300H\310B\310d\320R^\320^k\320kl\320lx\320xy\360\000\000z\001I\002\360\000\000I\002J\002\360\000\000J\002K\002\330\004\025\220Q\320\0260\260\001\330\004\013\2101";
+static const char __pyx_k_aq_Q_T_q_a_fHBd_VWWccddssttu_Q[] = "\200\001\360&\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\r\210T\220\026\220q\230\001\330\004\016\210a\330\004\021\220\037\240\002\240&\250\010\260\002\260$\260f\270H\300B\300d\310,\320VW\320Wc\320cd\320ds\320st\320tu\330\004\025\220Q\320\026(\250\001\330\004\013\2101";
+static const char __pyx_k_aq_Q_T_q_a_fHBd_m_hhiixxyyz_Qj[] = "\200\001\340+,\360&\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\r\210T\220\026\220q\230\001\330\004\016\210a\330\004\021\220\027\230\002\230&\240\010\250\002\250$\250f\260H\270B\270d\300,\310m\320[\\\320\\h\320hi\320ix\320xy\320yz\330\004\025\220Q\220j\240\001\330\004\013\2101";
+static const char __pyx_k_aq_Q_T_q_a_r_xr_V82T_QlZ_jjkkl[] = "\200\001\360&\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\r\210T\220\026\220q\230\001\330\004\016\210a\330\004\021\220\026\220r\230\026\230x\240r\250\024\250V\2608\2702\270T\300\034\310Q\310l\320Z[\320[j\320jk\320kl\330\004\025\220Q\220i\230q\330\004\013\2101";
+static const char __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_F_D[] = "\200\001\360,\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\013\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\n\210+\220Q\220a\330\004\017\210y\230\003\2301\330\004\014\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\r\210]\230!\2306\240\026\240u\250A\330\004\021\220\021\330\004\021\320\021\"\240\"\240F\250(\260\"\260D\270\006\270h\300b\310\004\310L\320Xd\320do\320o|\320|}\360\000\000~\001J\002\360\000\000J\002K\002\360\000\000K\002Z\002\360\000\000Z\002[\002\360\000\000[\002\\\002\330\004\025\220Q\320\026*\250!\330\004\013\2101";
+static const char __pyx_k_aq_Qa_Kq_6_a_8_T_3hjX_U_7_A_we[] = "\200\001\340[\\\360&\000\005\014\210;\220a\220q\330\004\n\210+\220Q\220a\330\004\014\210K\220q\230\001\330\004\r\210]\230!\2306\240\025\240a\330\004\r\210]\230!\2308\240:\250T\260\030\270\032\3003\300h\310j\320X]\320]^\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033,\250B\250a\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\030\230\022\2304\230y\250\013\2604\260v\270Q\270i\300{\320RU\320U[\320[\\\320\\e\320ep\320pu\320u{\320{|\360\000\000}\001F\002\360\000\000F\002S\002\360\000\000S\002T\002\360\000\000T\002`\002\360\000\000`\002a\002\360\000\000a\002p\002\360\000\000p\002{\002\360\000\000{\002B\003\360\000\000B\003H\003\360\000\000H\003I\003\360\000\000I\003J\003\330\004\025\220Q\220k\240\021\330\004\013\2101";
+static const char __pyx_k_aq_Qa_Kq_6_gQ_8_T_3hjX_eeoouuv[] = "\200\001\360&\000\005\014\210;\220a\220q\330\004\n\210+\220Q\220a\330\004\014\210K\220q\230\001\330\004\r\210[\230\001\230\021\330\004\r\210]\230!\2306\240\025\240g\250Q\330\004\r\210]\230!\2308\240:\250T\260\030\270\032\3003\300h\310j\320X]\320]e\320eo\320ou\320uv\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\230?\250!\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\026\220r\230\024\230Y\240k\260\024\260V\2701\270I\300[\320PS\320SY\320YZ\320Zc\320cn\320ns\320sy\320yz\360\000\000{\001D\002\360\000\000D\002O\002\360\000\000O\002U\002\360\000\000U\002[\002\360\000\000[\002\\\002\360\000\000\\\002e\002\360\000\000e\002f\002\360\000\000f\002r\002\360\000\000r\002s\002\360\000\000s\002B\003\360\000\000B\003M\003\360\000\000M\003T\003\360\000\000T\003Z\003\360\000\000Z\003[\003\360\000\000[\003\\\003\330\004\025\220Q\220i\230q\330\004\013\2101";
+static const char __pyx_k_aq_T_q_8_T_U_7_A_we_0_q_Rt9Kt6[] = "\200\001\340)*\360&\000\005\014\210;\220a\220q\330\004\r\210T\220\026\220q\230\001\330\004\r\210]\230!\2308\240:\250T\260\021\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\0330\260\002\260!\330\004\021\220\036\230q\240\010\250\001\330\004\021\220\034\230R\230t\2409\250K\260t\2706\300\021\300)\310=\320XY\320Ye\320ef\320fu\320u}\360\000\000~\001H\002\360\000\000H\002N\002\360\000\000N\002O\002\360\000\000O\002P\002\330\004\025\220Q\220o\240Q\330\004\026\220f\230J\240a\330\004\010\210\007\320\017\037\230q\330\010\027\220q\230\006\230a\330\004\013\2101";
+static const char __pyx_k_aq_T_q_8_T_U_7_A_we_1_81_Qha_b[] = "\200\001\360*\000\005\014\210;\220a\220q\330\004\r\210T\220\026\220q\230\001\330\004\r\210]\230!\2308\240:\250T\260\021\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\0331\260\021\330\004\021\320\021\"\240!\2408\2501\330\004\024\320\024%\240Q\240h\250a\330\004\021\220\035\230b\240\004\240I\250[\270\004\270F\300!\3009\310A\310\\\320YZ\320Zi\320it\320t~\360\000\000\177\001E\002\360\000\000E\002F\002\360\000\000F\002Q\002\360\000\000Q\002\\\002\360\000\000\\\002i\002\360\000\000i\002o\002\360\000\000o\002p\002\360\000\000p\002q\002\330\004\025\220Q\320\026&\240a\330\004\013\210=\230\001";
+static const char __pyx_k_aq_T_q_8_T_U_7_A_we_1_q_i_fAYa[] = "\200\001\360&\000\005\014\210;\220a\220q\330\004\r\210T\220\026\220q\230\001\330\004\r\210]\230!\2308\240:\250T\260\021\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033+\2501\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\027\230\002\230$\230i\240{\260$\260f\270A\270Y\300a\300|\320ST\320Tc\320cn\320nu\320u{\320{|\320|}\330\004\025\220Q\220j\240\001\330\004\013\2101";
+static const char __pyx_k_aq_T_q_8_T_U_7_A_we_Q_q_D_D_ay[] = "\200\001\360&\000\005\014\210;\220a\220q\330\004\r\210T\220\026\220q\230\001\330\004\r\210]\230!\2308\240:\250T\260\021\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033-\250Q\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\031\230\"\230D\240\t\250\033\260D\270\006\270a\270y\310\001\310\034\320UV\320Ve\320ep\320pw\320w}\320}~\320~\177\330\004\025\220Q\220l\240!\330\004\013\2101";
+static const char __pyx_k_aq_T_q_8_T_U_7_A_we_b_q_2T_T_q[] = "\200\001\340'(\360&\000\005\014\210;\220a\220q\330\004\r\210T\220\026\220q\230\001\330\004\r\210]\230!\2308\240:\250T\260\021\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033.\250b\260\001\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\032\2302\230T\240\031\250+\260T\270\026\270q\300\t\310\035\320VW\320Wc\320cd\320ds\320s~\360\000\000\177\001F\002\360\000\000F\002L\002\360\000\000L\002M\002\360\000\000M\002N\002\330\004\025\220Q\220m\2401\330\004\013\2101";
+static const char __pyx_k_aq_T_q_8_T_U_7_A_we_q_q_1HA_Bd[] = "\200\001\360*\000\005\014\210;\220a\220q\330\004\r\210T\220\026\220q\230\001\330\004\r\210]\230!\2308\240:\250T\260\021\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033/\250q\330\004\016\320\016\037\230q\240\010\250\001\330\004\022\320\022#\2401\240H\250A\330\004\021\220\033\230B\230d\240)\250;\260d\270&\300\001\300\031\310!\310<\320WX\320Xg\320gr\320ry\320y\177\360\000\000@\002A\002\360\000\000A\002L\002\360\000\000L\002W\002\360\000\000W\002b\002\360\000\000b\002h\002\360\000\000h\002i\002\360\000\000i\002j\002\330\004\025\220Q\220n\240A\330\004\013\210:\220Q";
+static const char __pyx_k_d_W_W_X_aq_Q_Qa_y_1_Kq_q_6_a_a[] = "\200\001\340d}\360\000\000~\001W\002\360\000\000W\002X\002\360.\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\n\210+\220Q\220a\330\004\017\210y\230\003\2301\330\004\014\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\r\210]\230!\2306\240\025\240a\330\004\016\210a\330\004\021\220\032\2302\230V\2408\2502\250T\260\026\260x\270r\300\024\300\\\320Q\\\320\\i\320iw\360\000\000x\001F\002\360\000\000F\002T\002\360\000\000T\002U\002\360\000\000U\002a\002\360\000\000a\002b\002\360\000\000b\002q\002\360\000\000q\002r\002\360\000\000r\002s\002\330\004\025\220Q\220m\2401\330\004\013\2101";
+static const char __pyx_k_d_Y_Y_Z_2_aq_Q_Qa_y_1_Kq_q_6_a[] = "\200\001\340d~\360\000\000\177\001Y\002\360\000\000Y\002Z\002\3602\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\n\210+\220Q\220a\330\004\017\210y\230\003\2301\330\004\014\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\r\210]\230!\2306\240\025\240a\330\004\017\210q\330\004\017\210q\330\004\021\220\032\2302\230V\2408\2502\250T\260\026\260x\270r\300\024\300\\\320Q\\\320\\i\320ix\360\000\000y\001H\002\360\000\000H\002W\002\360\000\000W\002X\002\360\000\000X\002d\002\360\000\000d\002e\002\360\000\000e\002t\002\360\000\000t\002u\002\360\000\000u\002@\003\360\000\000@\003A\003\360\000\000A\003B\003\330\004\025\220Q\220m\2401\330\004\013\210;\220a";
 static const char __pyx_k_input_array_type_is_not_double[] = "input array type is not double";
+static const char __pyx_k_q_9A_1_q_1_1_1A_q_a_1A_4z_A_G1[] = "\200\001\360\014\000\005\020\210q\330\004\020\220\001\220\031\230!\2309\240A\330\004\020\220\001\220\021\330\004\013\2101\330\004\010\210\007\210q\320\0201\260\022\2601\340\004\022\220)\2301\230A\330\004\010\210\007\210q\220\001\330\004\010\210\016\220a\330\010\020\220\013\2301\230A\330\010\013\2104\210z\230\021\230'\240\021\330\014\024\220A\330\010\014\210G\2201\320\024$\240L\260\001\340\004\r\210Y\220a\220q\330\004\007\200q\330\010\014\210G\2201\220A\330\004\010\210\t\220\021\330\010\014\210G\2201\320\024$\240G\2506\260\021\260!\330\010\021\220\027\230\001\230\035\240g\250V\2601\260A\330\010\020\220\001\220\031\230&\240\001\240\021\330\010\013\2106\220\023\220A\330\014\020\220\002\220%\220s\230%\230q\240\001\240\024\240R\240t\2507\260\"\260G\2701\270F\300!\3001\340\004\016\210i\220q\230\001\330\004\010\210\007\210q\220\001\330\004\010\210\n\220!\330\010\013\2107\220#\220Q\330\014\025\220Q\330\010\014\210G\2201\220I\230R\230q\340\004\r\210W\220A\220T\230\025\230a\230q\330\004\r\210W\220A\220Q\330\004\010\210\007\210q\220\003\2202\220U\230!\2301\330\004\024\220D\230\005\230Q\230a\330\004\013\210:\220Q";
+static const char __pyx_k_q_aq_T_q_8_T_U_7_A_we_b_Q_q_2T[] = "\200\001\340'?\270q\360(\000\005\014\210;\220a\220q\330\004\r\210T\220\026\220q\230\001\330\004\r\210]\230!\2308\240:\250T\260\021\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033.\250b\260\r\270Q\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\032\2302\230T\240\031\250+\260T\270\026\270q\300\t\310\035\320V^\320^_\320_k\320kl\320l{\360\000\000|\001G\002\360\000\000G\002N\002\360\000\000N\002T\002\360\000\000T\002U\002\360\000\000U\002V\002\330\004\025\220Q\220m\2401\330\004\013\2101";
+static const char __pyx_k_v_w_Q_Q_f_f_A_2_aq_Qa_Kq_6_a_8[] = "\200\001\340\\v\360\000\000w\001Q\002\360\000\000Q\002f\002\360\000\000f\002@\003\360\000\000@\003A\003\3602\000\005\014\210;\220a\220q\330\004\n\210+\220Q\220a\330\004\014\210K\220q\230\001\330\004\r\210]\230!\2306\240\025\240a\330\004\r\210]\230!\2308\240:\250T\260\030\270\032\3003\300h\310j\320X]\320]^\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033-\250R\250\177\270o\310_\320\\k\320kl\330\004\017\320\017 \240\001\240\030\250\021\330\004\017\320\017 \240\001\240\030\250\021\330\004\021\220\031\230\"\230D\240\t\250\033\260D\270\006\270a\270y\310\013\320SV\320V\\\320\\]\320]f\320fq\320qv\320v|\320|}\360\000\000~\001G\002\360\000\000G\002V\002\360\000\000V\002e\002\360\000\000e\002t\002\360\000\000t\002C\003\360\000\000C\003R\003\360\000\000R\003S\003\360\000\000S\003_\003\360\000\000_\003`\003\360\000\000`\003o\003\360\000\000o\003z\003\360\000\000z\003B\004\360\000\000B\004H\004\360\000\000H\004I\004\360\000\000I\004T\004\360\000\000T\004_\004\360\000\000_\004g\004\360\000\000g\004m\004\360\000\000m\004n\004\360\000\000n\004o\004\330\004\025\220Q\220l\240!\330\004\013\210;\220a";
+static const char __pyx_k_z_R_R_S_aq_Qa_Kq_6_gQ_8_T_3hjX[] = "\200\001\360\004\000z\001R\002\360\000\000R\002S\002\360(\000\005\014\210;\220a\220q\330\004\n\210+\220Q\220a\330\004\014\210K\220q\230\001\330\004\r\210[\230\001\230\021\330\004\r\210]\230!\2306\240\025\240g\250Q\330\004\r\210]\230!\2308\240:\250T\260\030\270\032\3003\300h\310j\320X]\320]e\320eo\320ou\320uv\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033-\250R\250}\270A\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\031\230\"\230D\240\t\250\033\260D\270\006\270a\270y\310\013\320SV\320V\\\320\\]\320]f\320fq\320qv\320v|\320|}\360\000\000~\001G\002\360\000\000G\002R\002\360\000\000R\002X\002\360\000\000X\002^\002\360\000\000^\002_\002\360\000\000_\002h\002\360\000\000h\002u\002\360\000\000u\002B\003\360\000\000B\003C\003\360\000\000C\003O\003\360\000\000O\003P\003\360\000\000P\003_\003\360\000\000_\003j\003\360\000\000j\003q\003\360\000\000q\003w\003\360\000\000w\003x\003\360\000\000x\003y\003\330\004\025\220Q\220l\240!\330\004\013\2101";
+static const char __pyx_k_01_aq_Q_T_q_RvXRt6_4_S_aammnn_Q[] = "\200\001\34001\360&\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\r\210T\220\026\220q\230\001\330\004\021\220\021\330\004\021\220\034\230R\230v\240X\250R\250t\2606\270\030\300\022\3004\300|\320S`\320`a\320am\320mn\320n}\320}~\320~\177\330\004\025\220Q\220o\240Q\330\004\013\2101";
+static const char __pyx_k_01_aq_Q_T_q_a_RvXRt6_4_S_aammnn[] = "\200\001\34001\360&\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\r\210T\220\026\220q\230\001\330\004\016\210a\330\004\021\220\034\230R\230v\240X\250R\250t\2606\270\030\300\022\3004\300|\320S`\320`a\320am\320mn\320n}\320}~\320~\177\330\004\025\220Q\220o\240Q\330\004\013\2101";
+static const char __pyx_k_0HHbb_0_aq_Q_T_q_q_q_RvXRt6_4_S[] = "\200\001\3400H\320Hb\320b|\320|}\3600\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\r\210T\220\026\220q\230\001\330\004\017\210q\330\004\017\210q\330\004\021\220\034\230R\230v\240X\250R\250t\2606\270\030\300\022\3004\300|\320S`\320`o\320o~\360\000\000\177\001N\002\360\000\000N\002O\002\360\000\000O\002[\002\360\000\000[\002\\\002\360\000\000\\\002k\002\360\000\000k\002l\002\360\000\000l\002w\002\360\000\000w\002x\002\360\000\000x\002y\002\330\004\025\220Q\220o\240Q\330\004\013\210;\220a";
+static const char __pyx_k_0_aq_Q_T_q_a_A_BfHBd_lRaabbnnoo[] = "\200\001\340/0\360.\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\r\210T\220\026\220q\230\001\330\004\016\210a\330\004\024\220A\330\004\022\220!\330\004\021\220\033\230B\230f\240H\250B\250d\260&\270\010\300\002\300$\300l\320Ra\320ab\320bn\320no\320o~\320~\177\360\000\000@\002J\002\360\000\000J\002K\002\360\000\000K\002[\002\360\000\000[\002\\\002\360\000\000\\\002]\002\330\004\025\220Q\220n\240A\330\004\013\210:\320\025%\240Q";
+static const char __pyx_k_0_aq_Q_T_q_a_BfHBd_lR___llmm_Qn[] = "\200\001\340/0\360&\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\r\210T\220\026\220q\230\001\330\004\016\210a\330\004\021\220\033\230B\230f\240H\250B\250d\260&\270\010\300\002\300$\300l\320R_\320_`\320`l\320lm\320m|\320|}\320}~\330\004\025\220Q\220n\240A\330\004\013\2101";
+static const char __pyx_k_12_aq_Q_T_q_a_b_hb_F_D_Taabbnno[] = "\200\001\34012\360&\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\r\210T\220\026\220q\230\001\330\004\016\210a\330\004\021\220\035\230b\240\006\240h\250b\260\004\260F\270(\300\"\300D\310\014\320Ta\320ab\320bn\320no\320o~\320~\177\360\000\000@\002A\002\330\004\025\220Q\320\026&\240a\330\004\013\2101";
+static const char __pyx_k_1_a_OuTUUV_Q_31_9AT_4q_1HF_wc_d[] = "\200\001\360\014\000\005\022\320\021+\2501\320,>\270a\320?O\310u\320TU\320UV\330\004\025\220Q\320\0263\2601\340\004\013\2109\220A\220T\230\021\330\004\013\2104\210q\220\003\2201\220H\230F\240!\340\004\007\200w\210c\220\025\220d\230%\230x\240x\250y\270\001\330\010\017\210t\2201\220C\220q\230\001\340\004\005\330\010\020\220\001\330\010\021\220\033\230A\230T\240\030\250\021";
+static const char __pyx_k_34_aq_Q_T_q_fHBd_Vccddppq_r_A_A[] = "\200\001\34034\360*\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\r\210T\220\026\220q\230\001\330\004\020\220\001\330\004\020\220\001\330\004\021\220\037\240\002\240&\250\010\260\002\260$\260f\270H\300B\300d\310,\320Vc\320cd\320dp\320pq\360\000\000r\001A\002\360\000\000A\002B\002\360\000\000B\002N\002\360\000\000N\002O\002\360\000\000O\002P\002\330\004\025\220Q\320\026(\250\001\330\004\013\210<\220q";
+static const char __pyx_k_45_aq_T_q_8_T_U_7_A_we_2Q_q_i_f[] = "\200\001\34045\360&\000\005\014\210;\220a\220q\330\004\r\210T\220\026\220q\230\001\330\004\r\210]\230!\2308\240:\250T\260\021\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033;\2702\270Q\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\320\021(\250\002\250$\250i\260{\300$\300f\310A\310Y\320Vc\320cd\320dp\320pq\360\000\000r\001A\002\360\000\000A\002L\002\360\000\000L\002S\002\360\000\000S\002Y\002\360\000\000Y\002Z\002\360\000\000Z\002[\002\330\004\025\220Q\320\0260\260\001\330\004\013\2101";
+static const char __pyx_k_5_t_Qm1_d_1_c_d_3a_Q_c_d_3a_Q_u[] = "\200\001\360\014\000\005\023\320\022#\2405\250\001\330\004\007\200t\210:\220Q\220m\2401\330\010\026\220d\230!\2301\330\004\016\210c\220\021\220$\220d\230!\2303\230a\230~\250Q\330\004\016\210c\220\021\220$\220d\230!\2303\230a\230~\250Q\360\006\000\005\010\200u\210B\210b\220\003\2205\230\002\230!\2302\230Q\330\010\017\210q\360\n\000\005\013\210!\330\004\010\210\005\210V\2201\220I\230W\240A\240Q\330\010\013\2101\210B\210b\220\002\220!\330\014\017\210w\220a\320\027(\250\001\250\021\250\"\250A\330\004\013\2101";
+static const char __pyx_k_78_aq_Q_T_q_a_BfHBd_lZgghhttu_v[] = "\200\001\34078\360&\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\r\210T\220\026\220q\230\001\330\004\016\210a\330\004\021\320\021$\240B\240f\250H\260B\260d\270&\300\010\310\002\310$\310l\320Zg\320gh\320ht\320tu\360\000\000v\001E\002\360\000\000E\002F\002\360\000\000F\002G\002\330\004\025\220Q\320\026,\250A\330\004\013\2101";
+static const char __pyx_k_AA_uuv0_aq_T_q_8_T_U_7_A_we_0_o[] = "\200\001\340)A\320A[\320[u\320uv\3600\000\005\014\210;\220a\220q\330\004\r\210T\220\026\220q\230\001\330\004\r\210]\230!\2308\240:\250T\260\021\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\0330\260\002\260-\270\177\310o\320]^\330\004\017\320\017 \240\001\240\030\250\021\330\004\017\320\017 \240\001\240\030\250\021\330\004\021\220\034\230R\230t\2409\250K\260t\2706\300\021\300)\310=\320Xg\320gv\360\000\000w\001F\002\360\000\000F\002G\002\360\000\000G\002S\002\360\000\000S\002T\002\360\000\000T\002c\002\360\000\000c\002n\002\360\000\000n\002v\002\360\000\000v\002|\002\360\000\000|\002}\002\360\000\000}\002H\003\360\000\000H\003S\003\360\000\000S\003[\003\360\000\000[\003a\003\360\000\000a\003b\003\360\000\000b\003c\003\330\004\025\220Q\220o\240Q\330\004\013\210;\220a";
+static const char __pyx_k_A_A_2_k_Qa_e_e1_2S_AQ_U_t1A_q_4[] = "\200A\360\016\000\t\021\220\004\220A\340\010\033\2302\230\\\250\025\250k\270\021\270+\300Q\300a\330\034 \240\016\250e\260;\270e\3001\330\010#\2402\240S\250\005\250\\\270\021\270\"\270A\270Q\330$(\250\005\250U\260!\360\006\000\t\020\210t\2201\220A\330\010\027\220q\330\010#\2404\320'B\300!\330\010\013\2105\220\004\220D\230\n\240!\2404\240q\250\004\250A\330\014\020\220\003\2207\230)\2401\240A\330\020\023\2204\220z\240\021\240%\240q\330\024\025\340\020\021\330\024 \240\001\320!9\270\021\270&\300\001\330\027\030\330\024\032\320\032G\300q\330\030\033\2301\230A\330\030\034\230E\240\021\240!\330\024\032\230)\2401\240A\340\010\013\320\013\036\230g\240Q\330\020\024\220J\230a\230u\240O\2601\330\014'\240u\250M\270\021\330\r \240\007\240q\330\020\024\220J\230a\230u\240O\2601\330\014'\240u\250M\270\031\300!\340\014'\240t\2504\250q\260\005\260Q\340\010\013\2103\210a\210~\230S\240\003\2401\240A\330\014\020\320\020!\240\021\240!\330\014\023\2204\220q\230\003\2301\230A\330\r\020\220\001\220\036\230t\320#<\270A\330\020\024\220C\220q\230\006\230c\240\024\240Z\250q\260\004\260A\260T\270\021\330\014\022\320\022A\300\021\330\020\023\2201\220A\330\020\024\220E\230\021\230!\330\014\022\220)\2301\230A\340\010\014\320\014\036\230b\240\010\250\001\330\010\014\320\014\034\230A\360\006\000\t\r\210L\230\t\240\021\330\014\021\220\033\230A\230[\250\001\250\033\260A\330\010\r\210U\220!\320\023#\2404\240q\360\006\000\t\r\210L\230\t\240\021\330\014\021\220\034\230Q\230k\250\021\320*<\270A\330\014\021\220\025\220a\220~\240Q\240n\260A\340\010\017\210t\2201";
+static const char __pyx_k_A_A_4wawa_1_Kq_Q_V1E_d_1_0_Ya_T[] = "\200A\340\010\020\220\004\220A\330\010\013\2104\210w\220a\220w\230a\330\014\021\220\030\230\021\330\014\021\320\021!\240\021\360\006\000\r\022\220\037\240\013\2501\330\014\021\220\036\230{\250!\330\014\021\220\033\230K\240q\330\014\021\320\021\"\240!\360\006\000\r\022\220\030\230\037\250\001\250\024\250Q\360\006\000\r\021\220\005\220V\2301\230E\240\025\240d\250!\2501\330\020\027\320\0270\260\001\260\024\260Y\270a\330\020\035\230T\240\021\240!\330\020\023\2204\220q\320\030(\250\003\2501\330\024\030\230\001\320\031+\320+H\310\001\310\021\330\020\025\220\\\240\021\240.\260\001\330\014\021\220\025\220a\320\027(\250\004\250A\360\006\000\r\021\220\005\220V\2301\230E\240\025\240d\250!\2501\330\020\027\320\0273\2601\260D\270\t\300\021\330\020\035\230T\240\021\240!\330\020\025\220[\240\001\240\036\250q\330\014\021\220\025\220a\320\027'\240t\2501\360\006\000\r\022\220\025\220a\320\027)\250\033\260A\330\014\020\220\005\220V\2301\230E\240\025\240d\250!\2501\330\020\027\320\0271\260\021\260$\260i\270q\330\020\036\230d\240!\2401\330\020\025\220U\230!\230?\250!\250?\270$\270a\270q\330\020\025\220X\230Q\230o\250Q\330\014\021\220\025\220a\320\027)\250\024\250Q\330\010\017\210q";
+static const char __pyx_k_A_A_a_G1_t3e1_aq_4_q_Q_AT_V1A_S[] = "\200A\360\010\000\t\021\220\004\220A\330\010\026\220a\340\010\014\210G\2201\330\014\017\210t\2203\220e\2301\330\020\030\230\006\230a\230q\330\020\023\2204\320\027/\250q\260\005\260Q\330\024\031\230\033\240A\240T\250\021\250+\260V\2701\270A\330\024\"\240!\330\021\025\220S\230\005\230Q\330\020\025\220\\\240\021\240$\240a\320'9\270\026\270q\300\001\330\020\025\220U\230!\230>\250\021\250'\260\026\260q\270\001\340\010\013\2101\330\014\031\230\021\330\014\017\210t\320\023$\240A\240T\250\021\250!\330\020\035\230Q\330\014\017\210s\220!\2206\230\022\2301\330\020\024\220C\220~\240Y\250a\250u\260A\330\024\031\230\021\330\024\027\220r\230\022\2303\230a\230q\330\030 \240\004\240A\240Q\330\030\033\2304\320\0377\260q\270\014\300A\330\034!\240\033\250A\250[\270\001\270\033\300A\330\034*\250!\340\010\013\2105\220\003\2201\330\014\017\210q\330\020\025\220U\230!\320\033+\2504\250q\330\014\021\320\021\"\240!";
+static const char __pyx_k_A_B_aq_aq_Qa_Kq_6_uA_8_T_4xzY_d[] = "\200\001\360\004\000A\002B\002\360&\000\005\014\210;\220a\220q\330\004\013\210;\220a\220q\330\004\n\210+\220Q\220a\330\004\014\210K\220q\230\001\330\004\r\210]\230!\2306\240\026\240u\250A\330\004\r\210]\230!\2308\240:\250T\260\030\270\032\3004\300x\310z\320Y\\\320\\d\320dn\320ns\320st\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\0336\260b\270\001\330\004\021\220\036\230q\240\010\250\001\330\004\021\320\021#\2402\240T\250\031\260+\270T\300\026\300q\310\t\320Q\\\320\\`\320`f\320fg\320gp\320p{\320{~\360\000\000\177\001E\002\360\000\000E\002F\002\360\000\000F\002O\002\360\000\000O\002Z\002\360\000\000Z\002_\002\360\000\000_\002e\002\360\000\000e\002f\002\360\000\000f\002o\002\360\000\000o\002}\002\360\000\000}\002~\002\360\000\000~\002J\003\360\000\000J\003K\003\360\000\000K\003Z\003\360\000\000Z\003b\003\360\000\000b\003l\003\360\000\000l\003r\003\360\000\000r\003s\003\360\000\000s\003t\003\330\004\025\220Q\320\026+\2501\330\004\013\2101";
+static const char __pyx_k_A_Y_Y_Z_aq_Q_Qa_y_1_Kq_q_6_6_gQ[] = "\200\001\360\004\000A\002Y\002\360\000\000Y\002Z\002\360.\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\n\210+\220Q\220a\330\004\017\210y\230\003\2301\330\004\014\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\r\210[\230\001\230\021\330\004\022\220)\2306\240\021\330\004\r\210]\230!\2306\240\025\240g\250Q\330\004\016\210a\330\004\021\220\031\230\"\230F\240(\250\"\250D\260\006\260h\270b\300\004\300L\320P[\320[h\320hv\360\000\000w\001D\002\360\000\000D\002Q\002\360\000\000Q\002R\002\360\000\000R\002^\002\360\000\000^\002_\002\360\000\000_\002n\002\360\000\000n\002o\002\360\000\000o\002p\002\330\004\025\220Q\220l\240!\330\004\013\2101";
+static const char __pyx_k_A_aq_Kq_6_8_T_5_U_7_A_we_2Q_q_i[] = "\200\001\340@A\360&\000\005\014\210;\220a\220q\330\004\014\210K\220q\230\001\330\004\r\210]\230!\2306\240\021\330\004\r\210]\230!\2308\240:\250T\260\030\270\032\3005\310\001\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033+\2502\250Q\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\027\230\002\230$\230i\240{\260$\260f\270A\270Y\300k\320QV\320V\\\320\\]\320]f\320fs\320st\360\000\000u\001A\002\360\000\000A\002B\002\360\000\000B\002Q\002\360\000\000Q\002\\\002\360\000\000\\\002c\002\360\000\000c\002i\002\360\000\000i\002j\002\360\000\000j\002k\002\330\004\025\220Q\220j\240\001\330\004\013\2101";
+static const char __pyx_k_A_aq_Qa_6_8_T_3a_U_7_A_we_Rq_AX[] = "\200\001\340@A\360*\000\005\014\210;\220a\220q\330\004\n\210+\220Q\220a\330\004\r\210]\230!\2306\240\021\330\004\r\210]\230!\2308\240:\250T\260\030\270\032\3003\300a\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033-\250R\250q\330\004\023\320\023$\240A\240X\250Q\330\004\021\320\021\"\240!\2408\2501\330\004\021\220\031\230\"\230D\240\t\250\033\260D\270\006\270a\270y\310\013\320SV\320V\\\320\\]\320]f\320fs\320st\360\000\000u\001A\002\360\000\000A\002B\002\360\000\000B\002Q\002\360\000\000Q\002\\\002\360\000\000\\\002h\002\360\000\000h\002n\002\360\000\000n\002o\002\360\000\000o\002z\002\360\000\000z\002E\003\360\000\000E\003O\003\360\000\000O\003U\003\360\000\000U\003V\003\360\000\000V\003W\003\330\004\025\220Q\220l\240!\330\004\013\210?\230!";
+static const char __pyx_k_A_aq_T_q_8_T_U_7_A_we_2_q_i_fAY[] = "\200\001\340$<\270A\360(\000\005\014\210;\220a\220q\330\004\r\210T\220\026\220q\230\001\330\004\r\210]\230!\2308\240:\250T\260\021\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033+\2502\250]\270!\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\027\230\002\230$\230i\240{\260$\260f\270A\270Y\300m\320S[\320[\\\320\\h\320hi\320ix\360\000\000y\001D\002\360\000\000D\002K\002\360\000\000K\002Q\002\360\000\000Q\002R\002\360\000\000R\002S\002\330\004\025\220Q\220j\240\001\330\004\013\2101";
+static const char __pyx_k_A_z_____b_b_G_G_h_h_i_4_aq_Qa_6[] = "\200\001\340A[\320[z\360\000\000{\001_\002\360\000\000_\002\177\002\360\000\000\177\002b\003\360\000\000b\003G\004\360\000\000G\004h\004\360\000\000h\004i\004\3604\000\005\014\210;\220a\220q\330\004\n\210+\220Q\220a\330\004\r\210]\230!\2306\240\021\330\004\r\210]\230!\2308\240:\250T\260\030\270\032\3003\300a\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033.\250b\260\r\320=O\320Of\320fy\360\000\000z\001P\002\360\000\000P\002h\002\360\000\000h\002|\002\360\000\000|\002}\002\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\032\2302\230T\240\031\250+\260T\270\026\270q\300\t\310\033\320TW\320W]\320]^\320^g\320gt\360\000\000u\001G\002\360\000\000G\002^\002\360\000\000^\002q\002\360\000\000q\002G\003\360\000\000G\003_\003\360\000\000_\003s\003\360\000\000s\003J\004\360\000\000J\004K\004\360\000\000K\004W\004\360\000\000W\004X\004\360\000\000X\004g\004\360\000\000g\004r\004\360\000\000r\004y\004\360\000\000y\004\177\004\360\000\000\177\004@\005\360\000\000@\005A\005\330\004\025\220Q\220m\2401\330\004\013\2101";
+static const char __pyx_k_B_aq_Q_T_q_a_r_xr_V82T_Zccddppq[] = "\200\001\340*B\300!\360(\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\r\210T\220\026\220q\230\001\330\004\016\210a\330\004\021\220\026\220r\230\026\230x\240r\250\024\250V\2608\2702\270T\300\034\310]\320Zc\320cd\320dp\320pq\360\000\000r\001A\002\360\000\000A\002B\002\360\000\000B\002C\002\330\004\025\220Q\220i\230q\330\004\013\2101";
+static const char __pyx_k_B_aq_Q_T_q_a_r_xr_V82T_Zddeeqqr[] = "\200\001\340*B\300!\360(\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\r\210T\220\026\220q\230\001\330\004\016\210a\330\004\021\220\026\220r\230\026\230x\240r\250\024\250V\2608\2702\270T\300\034\310]\320Zd\320de\320eq\320qr\360\000\000s\001B\002\360\000\000B\002C\002\360\000\000C\002D\002\330\004\025\220Q\220i\230q\330\004\013\2101";
+static const char __pyx_k_CC_aq_Q_T_q_a_fHBd_m_hhqqrr_O_O[] = "\200\001\340+C\320C[\320[\\\360*\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\r\210T\220\026\220q\230\001\330\004\016\210a\330\004\021\220\027\230\002\230&\240\010\250\002\250$\250f\260H\270B\270d\300,\310m\320[h\320hq\320qr\320r~\320~\177\360\000\000@\002O\002\360\000\000O\002P\002\360\000\000P\002Q\002\330\004\025\220Q\220j\240\001\330\004\013\2101";
+static const char __pyx_k_CZZqqr_aq_k_6_8_T_7_U_7_A_we_Bl[] = "\200\001\340CZ\320Zq\320qr\360,\000\005\014\210;\220a\220q\330\004\016\210k\230\021\230!\330\004\r\210]\230!\2306\240\021\330\004\r\210]\230!\2308\240:\250T\260\030\270\032\3007\310!\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033,\250B\250l\270,\300a\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\030\230\022\2304\230y\250\013\2604\260v\270Q\270i\300{\320RY\320Y_\320_`\320`i\320iu\360\000\000v\001B\002\360\000\000B\002K\002\360\000\000K\002L\002\360\000\000L\002X\002\360\000\000X\002Y\002\360\000\000Y\002h\002\360\000\000h\002s\002\360\000\000s\002z\002\360\000\000z\002@\003\360\000\000@\003A\003\360\000\000A\003B\003\330\004\025\220Q\220k\240\021\330\004\013\2101";
+static const char __pyx_k_C_D_aq_aq_Qa_Kq_6_uA_8_T_4xzY_d[] = "\200\001\360\004\000C\002D\002\360&\000\005\014\210;\220a\220q\330\004\013\210;\220a\220q\330\004\n\210+\220Q\220a\330\004\014\210K\220q\230\001\330\004\r\210]\230!\2306\240\026\240u\250A\330\004\r\210]\230!\2308\240:\250T\260\030\270\032\3004\300x\310z\320Y\\\320\\d\320dn\320ns\320st\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\0338\270\002\270!\330\004\021\220\036\230q\240\010\250\001\330\004\021\320\021%\240R\240t\2509\260K\270t\3006\310\021\310)\320S^\320^b\320bh\320hi\320ir\320r}\360\000\000~\001A\002\360\000\000A\002G\002\360\000\000G\002H\002\360\000\000H\002Q\002\360\000\000Q\002\\\002\360\000\000\\\002a\002\360\000\000a\002g\002\360\000\000g\002h\002\360\000\000h\002q\002\360\000\000q\002\177\002\360\000\000\177\002@\003\360\000\000@\003L\003\360\000\000L\003M\003\360\000\000M\003\\\003\360\000\000\\\003d\003\360\000\000d\003n\003\360\000\000n\003t\003\360\000\000t\003u\003\360\000\000u\003v\003\330\004\025\220Q\320\026-\250Q\330\004\013\2101";
+static const char __pyx_k_DD_2_aq_Q_T_q_a_A_6_4vXRt_iixxy[] = "\200\001\340,D\320D\\\320\\]\3602\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\r\210T\220\026\220q\230\001\330\004\016\210a\330\004\024\220A\330\004\022\220!\330\004\021\220\030\230\022\2306\240\030\250\022\2504\250v\260X\270R\270t\300<\310}\320\\i\320ix\320xy\360\000\000z\001F\002\360\000\000F\002G\002\360\000\000G\002V\002\360\000\000V\002W\002\360\000\000W\002a\002\360\000\000a\002b\002\360\000\000b\002r\002\360\000\000r\002s\002\360\000\000s\002t\002\330\004\025\220Q\220k\240\021\330\004\013\210:\320\025%\240Q";
+static const char __pyx_k_DE_Kq_Kq_7_8_U_E_U_7_A_we_b_q_2[] = "\200\001\340DE\360(\000\005\r\210K\220q\230\001\330\004\014\210K\220q\230\001\330\004\r\210]\230!\2307\240!\330\004\r\210]\230!\2308\240:\250U\260(\270*\300E\310\021\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033.\250b\260\001\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\032\2302\230T\240\031\250+\260U\270&\300\001\300\031\310+\320UZ\320Z`\320`a\320aj\320jw\320wx\360\000\000y\001E\002\360\000\000E\002F\002\360\000\000F\002U\002\360\000\000U\002`\002\360\000\000`\002g\002\360\000\000g\002m\002\360\000\000m\002n\002\360\000\000n\002o\002\330\004\025\220Q\220m\2401\330\004\013\2101";
+static const char __pyx_k_D_E_aq_aq_Qa_Kq_6_uA_8_T_4xzY_d[] = "\200\001\360\004\000D\002E\002\360&\000\005\014\210;\220a\220q\330\004\013\210;\220a\220q\330\004\n\210+\220Q\220a\330\004\014\210K\220q\230\001\330\004\r\210]\230!\2306\240\026\240u\250A\330\004\r\210]\230!\2308\240:\250T\260\030\270\032\3004\300x\310z\320Y\\\320\\d\320dn\320ns\320st\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\0339\270\022\2701\330\004\021\220\036\230q\240\010\250\001\330\004\021\320\021&\240b\250\004\250I\260[\300\004\300F\310!\3109\320T_\320_c\320ci\320ij\320js\320s~\360\000\000\177\001B\002\360\000\000B\002H\002\360\000\000H\002I\002\360\000\000I\002R\002\360\000\000R\002]\002\360\000\000]\002b\002\360\000\000b\002h\002\360\000\000h\002i\002\360\000\000i\002r\002\360\000\000r\002@\003\360\000\000@\003A\003\360\000\000A\003M\003\360\000\000M\003N\003\360\000\000N\003]\003\360\000\000]\003e\003\360\000\000e\003o\003\360\000\000o\003u\003\360\000\000u\003v\003\360\000\000v\003w\003\330\004\025\220Q\320\026.\250a\330\004\013\2101";
+static const char __pyx_k_EQ_aq_Q_T_q_a_a_6_4vXRt_gghhttu[] = "\200\001\340,E\300Q\360,\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\r\210T\220\026\220q\230\001\330\004\016\210a\330\004\016\210a\330\004\021\220\030\230\022\2306\240\030\250\022\2504\250v\260X\270R\270t\300<\310|\320[g\320gh\320ht\320tu\360\000\000v\001E\002\360\000\000E\002F\002\360\000\000F\002P\002\360\000\000P\002Q\002\360\000\000Q\002R\002\330\004\025\220Q\220k\240\021\330\004\013\210:\220Q";
+static const char __pyx_k_E_F_aq_aq_Qa_Kq_6_uA_8_T_4xzY_d[] = "\200\001\360\004\000E\002F\002\360&\000\005\014\210;\220a\220q\330\004\013\210;\220a\220q\330\004\n\210+\220Q\220a\330\004\014\210K\220q\230\001\330\004\r\210]\230!\2306\240\026\240u\250A\330\004\r\210]\230!\2308\240:\250T\260\030\270\032\3004\300x\310z\320Y\\\320\\d\320dn\320ns\320st\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033:\270\"\270A\330\004\021\220\036\230q\240\010\250\001\330\004\021\320\021'\240r\250\024\250Y\260k\300\024\300V\3101\310I\320U`\320`d\320dj\320jk\320kt\320t\177\360\000\000@\002C\002\360\000\000C\002I\002\360\000\000I\002J\002\360\000\000J\002S\002\360\000\000S\002^\002\360\000\000^\002c\002\360\000\000c\002i\002\360\000\000i\002j\002\360\000\000j\002s\002\360\000\000s\002A\003\360\000\000A\003B\003\360\000\000B\003N\003\360\000\000N\003O\003\360\000\000O\003^\003\360\000\000^\003f\003\360\000\000f\003p\003\360\000\000p\003v\003\360\000\000v\003w\003\360\000\000w\003x\003\330\004\025\220Q\320\026/\250q\330\004\013\2101";
+static const char __pyx_k_E_a_aq_Q_Qa_y_1_6_a_fHBd_kYhhrr[] = "\200\001\340E`\320`a\360*\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\n\210+\220Q\220a\330\004\017\210y\230\003\2301\330\004\r\210]\230!\2306\240\021\330\004\016\210a\330\004\021\220\027\230\002\230&\240\010\250\002\250$\250f\260H\270B\270d\300,\310k\320Yh\320hr\320rs\320s\177\360\000\000@\002A\002\360\000\000A\002P\002\360\000\000P\002Q\002\360\000\000Q\002R\002\330\004\025\220Q\220j\240\001\330\004\013\2101";
+static const char __pyx_k_FF_ttu4_aq_Q_T_q_q_q_2V82T_xr_Q[] = "\200\001\340.F\320F]\320]t\320tu\3604\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\r\210T\220\026\220q\230\001\330\004\027\220q\330\004\030\230\001\330\004\027\220q\330\004\021\220\032\2302\230V\2408\2502\250T\260\026\260x\270r\300\024\300\\\320Q^\320^h\320hr\320r{\320{|\360\000\000}\001I\002\360\000\000I\002J\002\360\000\000J\002Y\002\360\000\000Y\002Z\002\360\000\000Z\002m\002\360\000\000m\002n\002\360\000\000n\002B\003\360\000\000B\003C\003\360\000\000C\003D\003\330\004\025\220Q\220m\2401\330\004\013\320\013\036\320\0362\260!";
+static const char __pyx_k_Fa_aq_Q_T_q_a_2V82T_xr_Q_ffggss[] = "\200\001\340.F\300a\360(\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\r\210T\220\026\220q\230\001\330\004\016\210a\330\004\021\220\032\2302\230V\2408\2502\250T\260\026\260x\270r\300\024\300\\\320Q^\320^f\320fg\320gs\320st\360\000\000u\001D\002\360\000\000D\002E\002\360\000\000E\002F\002\330\004\025\220Q\220m\2401\330\004\013\2101";
 static const char __pyx_k_Function__check_opt_input_value[] = "_Function__check_opt_input_value";
-static const char __pyx_k_Function__initialize_function_i[] = "_Function__initialize_function_info";
 static const char __pyx_k_Function__input_price_series_na[] = "_Function__input_price_series_names";
 static const char __pyx_k_Function_has_an_unstable_period[] = "Function has an unstable period";
+static const char __pyx_k_GGZZr_s_F_F_a_8_aq_Q_T_q_a_A_Bf[] = "\200\001\340/G\320GZ\320Zr\360\000\000s\001F\002\360\000\000F\002`\002\360\000\000`\002a\002\3608\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\r\210T\220\026\220q\230\001\330\004\016\210a\330\004\024\220A\330\004\022\220!\330\004\021\220\033\230B\230f\240H\250B\250d\260&\270\010\300\002\300$\300l\320R_\320_l\320ly\360\000\000z\001G\002\360\000\000G\002V\002\360\000\000V\002e\002\360\000\000e\002f\002\360\000\000f\002r\002\360\000\000r\002s\002\360\000\000s\002B\003\360\000\000B\003C\003\360\000\000C\003M\003\360\000\000M\003N\003\360\000\000N\003^\003\360\000\000^\003_\003\360\000\000_\003`\003\330\004\025\220Q\220n\240A\330\004\013\210:\320\025%\240Q";
+static const char __pyx_k_GH_aq_Q_Kq_q_6_a_fHBd_m_hhiiuuv[] = "\200\001\340GH\360(\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\014\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\r\210]\230!\2306\240\021\330\004\016\210a\330\004\021\220\027\230\002\230&\240\010\250\002\250$\250f\260H\270B\270d\300,\310m\320[h\320hi\320iu\320uv\360\000\000w\001F\002\360\000\000F\002G\002\360\000\000G\002H\002\330\004\025\220Q\220j\240\001\330\004\013\2101";
+static const char __pyx_k_GH_aq_Q_Qa_y_1_6_1_F_D_hb_LP_hh[] = "\200\001\340GH\360,\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\n\210+\220Q\220a\330\004\017\210y\230\003\2301\330\004\r\210]\230!\2306\240\021\330\004\023\2201\330\004\021\220\021\330\004\021\220\031\230\"\230F\240(\250\"\250D\260\006\260h\270b\300\004\300L\320P[\320[h\320hi\320iu\320uv\360\000\000w\001F\002\360\000\000F\002G\002\360\000\000G\002V\002\360\000\000V\002W\002\360\000\000W\002X\002\330\004\025\220Q\220l\240!\330\004\013\210?\230!";
+static const char __pyx_k_IJ_Kq_q_Kq_q_7_a_6_4vXRt_P_jjkk[] = "\200\001\340IJ\360*\000\005\r\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\014\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\r\210]\230!\2307\240!\330\004\016\210a\330\004\021\220\030\230\022\2306\240\030\250\022\2504\250v\260X\270R\270t\300=\320P]\320]j\320jk\320kw\320wx\360\000\000y\001H\002\360\000\000H\002I\002\360\000\000I\002J\002\330\004\025\220Q\220k\240\021\330\004\013\2101";
+static const char __pyx_k_IJ_aq_Q_Qa_y_1_6_a_BfHBd_lR_jjk[] = "\200\001\340IJ\360(\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\n\210+\220Q\220a\330\004\017\210y\230\003\2301\330\004\r\210]\230!\2306\240\021\330\004\016\210a\330\004\021\220\033\230B\230f\240H\250B\250d\260&\270\010\300\002\300$\300l\320R]\320]j\320jk\320kw\320wx\360\000\000y\001H\002\360\000\000H\002I\002\360\000\000I\002J\002\330\004\025\220Q\220n\240A\330\004\013\2101";
+static const char __pyx_k_JK_aq_Q_Qa_y_1_6_a_RvXRt6_4_S_k[] = "\200\001\340JK\360(\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\n\210+\220Q\220a\330\004\017\210y\230\003\2301\330\004\r\210]\230!\2306\240\021\330\004\016\210a\330\004\021\220\034\230R\230v\240X\250R\250t\2606\270\030\300\022\3004\300|\320S^\320^k\320kl\320lx\320xy\360\000\000z\001I\002\360\000\000I\002J\002\360\000\000J\002K\002\330\004\025\220Q\220o\240Q\330\004\013\2101";
+static const char __pyx_k_Jaaxxy_aq_Q_k_9G1_6_a_6_4vXRt_j[] = "\200\001\340Ja\320ax\320xy\360.\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\016\210k\230\021\230!\330\004\023\2209\230G\2401\330\004\r\210]\230!\2306\240\021\330\004\016\210a\330\004\021\220\030\230\022\2306\240\030\250\022\2504\250v\260X\270R\270t\300<\310\177\320^j\320jv\320v\177\360\000\000@\002A\002\360\000\000A\002M\002\360\000\000M\002N\002\360\000\000N\002]\002\360\000\000]\002^\002\360\000\000^\002_\002\330\004\025\220Q\220k\240\021\330\004\013\2101";
+static const char __pyx_k_KL_Kq_q_Kq_q_7_a_2V82T_xr_R__ll[] = "\200\001\340KL\360*\000\005\r\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\014\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\r\210]\230!\2307\240!\330\004\016\210a\330\004\021\220\032\2302\230V\2408\2502\250T\260\026\260x\270r\300\024\300]\320R_\320_l\320lm\320my\320yz\360\000\000{\001J\002\360\000\000J\002K\002\360\000\000K\002L\002\330\004\025\220Q\220m\2401\330\004\013\2101";
 static const char __pyx_k_Kaufman_Adaptive_Moving_Average[] = "Kaufman Adaptive Moving Average";
+static const char __pyx_k_Kq_Kq_7_8_U_E_U_7_A_we_1_q_i_vQ[] = "\200\001\360(\000\005\r\210K\220q\230\001\330\004\014\210K\220q\230\001\330\004\r\210]\230!\2307\240!\330\004\r\210]\230!\2308\240:\250U\260(\270*\300E\310\021\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033+\2501\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\027\230\002\230$\230i\240{\260%\260v\270Q\270i\300{\320RW\320W]\320]^\320^g\320gh\320ht\320tu\360\000\000v\001E\002\360\000\000E\002P\002\360\000\000P\002W\002\360\000\000W\002]\002\360\000\000]\002^\002\360\000\000^\002_\002\330\004\025\220Q\220j\240\001\330\004\013\2101";
+static const char __pyx_k_Kq_Kq_7_8_U_E_U_7_A_we_A_q_4y_5[] = "\200\001\360(\000\005\r\210K\220q\230\001\330\004\014\210K\220q\230\001\330\004\r\210]\230!\2307\240!\330\004\r\210]\230!\2308\240:\250U\260(\270*\300E\310\021\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033,\250A\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\030\230\022\2304\230y\250\013\2605\270\006\270a\270y\310\013\320SX\320X^\320^_\320_h\320hi\320iu\320uv\360\000\000w\001F\002\360\000\000F\002Q\002\360\000\000Q\002X\002\360\000\000X\002^\002\360\000\000^\002_\002\360\000\000_\002`\002\330\004\025\220Q\220k\240\021\330\004\013\2101";
 static const char __pyx_k_Out_of_Range_Start_Index_TA_OUT[] = "Out-of-Range Start Index (TA_OUT_OF_RANGE_START_INDEX)";
+static const char __pyx_k_Q_NeSTTU_Q_2_9AT_4q_1G6_wc_t81H[] = "\200\001\360\014\000\005\022\320\021*\250!\320+=\270Q\320>N\310e\320ST\320TU\330\004\025\220Q\320\0262\260!\340\004\013\2109\220A\220T\230\021\330\004\013\2104\210q\220\003\2201\220G\2306\240\021\330\004\007\200w\210c\220\021\330\010\017\210t\2208\2301\230H\240A\330\t\021\220\023\220A\330\010\017\210q\340\004\005\330\010\020\220\001\330\010\030\230\013\2401\240D\250\010\260\001";
+static const char __pyx_k_SSkk_Y_Y_Z_8_aq_T_q_8_T_U_7_A_w[] = "\200\001\340(@\320@S\320Sk\320k~\360\000\000\177\001Y\002\360\000\000Y\002Z\002\3608\000\005\014\210;\220a\220q\330\004\r\210T\220\026\220q\230\001\330\004\r\210]\230!\2308\240:\250T\260\021\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033/\250r\260\035\270m\310=\320Xe\320et\320tu\330\004\016\320\016\037\230q\240\010\250\001\330\004\024\320\024%\240Q\240h\250a\330\004\022\320\022#\2401\240H\250A\330\004\021\220\033\230B\230d\240)\250;\260d\270&\300\001\300\031\310-\320Wd\320dq\320q~\360\000\000\177\001N\002\360\000\000N\002]\002\360\000\000]\002^\002\360\000\000^\002j\002\360\000\000j\002k\002\360\000\000k\002z\002\360\000\000z\002E\003\360\000\000E\003L\003\360\000\000L\003R\003\360\000\000R\003S\003\360\000\000S\003^\003\360\000\000^\003i\003\360\000\000i\003v\003\360\000\000v\003|\003\360\000\000|\003}\003\360\000\000}\003H\004\360\000\000H\004S\004\360\000\000S\004^\004\360\000\000^\004d\004\360\000\000d\004e\004\360\000\000e\004f\004\330\004\025\220Q\220n\240A\330\004\013\210:\320\025%\240Q";
 static const char __pyx_k_TA_RestoreCandleDefaultSettings[] = "TA_RestoreCandleDefaultSettings";
-static const char __pyx_k_This_is_a_pythonic_wrapper_arou[] = "\n    This is a pythonic wrapper around TALIB's abstract interface. It is\n    intended to simplify using individual TALIB functions by providing a\n    unified interface for setting/controlling input data, setting function\n    parameters and retrieving results. Input data consists of a ``dict`` of\n    ``numpy`` arrays (or a ``pandas.DataFrame``), one array for each of open,\n    high, low, close and volume. This can be set with the set_input_arrays()\n    method. Which keyed array(s) are used as inputs when calling the function\n    is controlled using the input_names property.\n\n    This class gets initialized with a TALIB function name and optionally an\n    input_arrays object. It provides the following primary functions for\n    setting inputs and retrieving results:\n\n    ---- input_array/TA-function-parameter set-only functions -----\n    - set_input_arrays(input_arrays)\n    - set_function_args([input_arrays,] [param_args_andor_kwargs])\n\n    Documentation for param_args_andor_kwargs can be seen by printing the\n    Function instance or programatically via the info, input_names and\n    parameters properties.\n\n    ----- result-returning functions -----\n    - the outputs property wraps a method which ensures results are always valid\n    - run([input_arrays]) # calls set_input_arrays and returns self.outputs\n    - FunctionInstance([input_arrays,] [param_args_andor_kwargs]) # calls set_function_args and returns self.outputs\n    ";
+static const char __pyx_k_TTU_aq_T_q_8_T_U_7_A_we_2_q_q_i[] = "\200\001\340$<\320<T\320TU\360*\000\005\014\210;\220a\220q\330\004\r\210T\220\026\220q\230\001\330\004\r\210]\230!\2308\240:\250T\260\021\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033+\2502\250]\270-\300q\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\027\230\002\230$\230i\240{\260$\260f\270A\270Y\300m\320S`\320`i\320ij\320jv\320vw\360\000\000x\001G\002\360\000\000G\002R\002\360\000\000R\002Y\002\360\000\000Y\002_\002\360\000\000_\002`\002\360\000\000`\002a\002\330\004\025\220Q\220j\240\001\330\004\013\2101";
+static const char __pyx_k_This_is_a_pythonic_wrapper_arou[] = "\n    This is a pythonic wrapper around TALIB's abstract interface. It is\n    intended to simplify using individual TALIB functions by providing a\n    unified interface for setting/controlling input data, setting function\n    parameters and retrieving results. Input data consists of a ``dict`` of\n    ``numpy`` arrays (or a ``pandas.DataFrame`` or ``polars.DataFrame``), one\n    array for each of open, high, low, close and volume. This can be set with\n    the set_input_arrays() method. Which keyed array(s) are used as inputs when\n    calling the function is controlled using the input_names property.\n\n    This class gets initialized with a TALIB function name and optionally an\n    input_arrays object. It provides the following primary functions for\n    setting inputs and retrieving results:\n\n    ---- input_array/TA-function-parameter set-only functions -----\n    - set_input_arrays(input_arrays)\n    - set_function_args([input_arrays,] [param_args_andor_kwargs])\n\n    Documentation for param_args_andor_kwargs can be seen by printing the\n    Function instance or programmatically via the info, input_names and\n    parameters properties.\n\n    ----- result-returning functions -----\n    - the outputs property wraps a method which ensures results are always valid\n    - run([input_arrays]) # calls set_input_arrays and returns self.outputs\n    - FunctionInstance([input_arrays,] [param_args_andor_kwargs]) # calls set_function_args and returns self.outputs\n    ";
+static const char __pyx_k_UUV2_aq_T_q_8_T_U_7_A_we_Bm_q_Q[] = "\200\001\340%=\320=U\320UV\3602\000\005\014\210;\220a\220q\330\004\r\210T\220\026\220q\230\001\330\004\r\210]\230!\2308\240:\250T\260\021\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033,\250B\250m\270=\310\001\330\004\016\320\016\037\230q\240\010\250\001\330\004\024\320\024%\240Q\240h\250a\330\004\022\320\022#\2401\240H\250A\330\004\021\220\030\230\022\2304\230y\250\013\2604\260v\270Q\270i\300}\320Ta\320ap\320pq\320q}\320}~\360\000\000\177\001N\002\360\000\000N\002Y\002\360\000\000Y\002`\002\360\000\000`\002f\002\360\000\000f\002g\002\360\000\000g\002r\002\360\000\000r\002}\002\360\000\000}\002J\003\360\000\000J\003P\003\360\000\000P\003Q\003\360\000\000Q\003\\\003\360\000\000\\\003g\003\360\000\000g\003r\003\360\000\000r\003x\003\360\000\000x\003y\003\360\000\000y\003z\003\330\004\025\220Q\220k\240\021\330\004\013\210:\320\025%\240Q";
+static const char __pyx_k_VVmmn4_aq_T_q_8_T_U_7_A_we_b_Zz[] = "\200\001\340'?\320?V\320Vm\320mn\3604\000\005\014\210;\220a\220q\330\004\r\210T\220\026\220q\230\001\330\004\r\210]\230!\2308\240:\250T\260\021\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033.\250b\260\r\270Z\300z\320QR\330\004\027\320\027(\250\001\250\030\260\021\330\004\030\320\030)\250\021\250(\260!\330\004\027\320\027(\250\001\250\030\260\021\330\004\021\220\032\2302\230T\240\031\250+\260T\270\026\270q\300\t\310\035\320V`\320`j\320js\320st\360\000\000u\001A\002\360\000\000A\002B\002\360\000\000B\002Q\002\360\000\000Q\002\\\002\360\000\000\\\002l\002\360\000\000l\002r\002\360\000\000r\002s\002\360\000\000s\002~\002\360\000\000~\002I\003\360\000\000I\003Z\003\360\000\000Z\003`\003\360\000\000`\003a\003\360\000\000a\003l\003\360\000\000l\003w\003\360\000\000w\003G\004\360\000\000G\004M\004\360\000\000M\004N\004\360\000\000N\004O\004\330\004\025\220Q\220m\2401\330\004\013\320\013\036\320\0362\260!";
 static const char __pyx_k_Values_represent_an_upper_limit[] = "Values represent an upper limit";
+static const char __pyx_k_YYZ_aq_Qa_6_8_T_3a_U_7_A_we_2_A[] = "\200\001\340>Y\320YZ\360(\000\005\014\210;\220a\220q\330\004\n\210+\220Q\220a\330\004\r\210]\230!\2306\240\021\330\004\r\210]\230!\2308\240:\250T\260\030\270\032\3003\300a\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033+\2502\250_\270A\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\027\230\002\230$\230i\240{\260$\260f\270A\270Y\300k\320QT\320TZ\320Z[\320[d\320ds\320s}\320}~\360\000\000\177\001K\002\360\000\000K\002L\002\360\000\000L\002[\002\360\000\000[\002f\002\360\000\000f\002m\002\360\000\000m\002s\002\360\000\000s\002t\002\360\000\000t\002u\002\330\004\025\220Q\220j\240\001\330\004\013\2101";
+static const char __pyx_k_Z_aq_Qa_Kq_6_a_8_T_3hjX_U_7_A_w[] = "\200\001\340Z[\360&\000\005\014\210;\220a\220q\330\004\n\210+\220Q\220a\330\004\014\210K\220q\230\001\330\004\r\210]\230!\2306\240\025\240a\330\004\r\210]\230!\2308\240:\250T\260\030\270\032\3003\300h\310j\320X]\320]^\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033+\2502\250Q\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\027\230\002\230$\230i\240{\260$\260f\270A\270Y\300k\320QT\320TZ\320Z[\320[d\320do\320ot\320tz\320z{\360\000\000|\001E\002\360\000\000E\002R\002\360\000\000R\002S\002\360\000\000S\002_\002\360\000\000_\002`\002\360\000\000`\002o\002\360\000\000o\002z\002\360\000\000z\002A\003\360\000\000A\003G\003\360\000\000G\003H\003\360\000\000H\003I\003\330\004\025\220Q\220j\240\001\330\004\013\2101";
+static const char __pyx_k_a_aq_Q_Qa_y_1_Kq_q_6_a_a_r_xr_V[] = "\200\001\340`a\360*\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\n\210+\220Q\220a\330\004\017\210y\230\003\2301\330\004\014\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\r\210]\230!\2306\240\025\240a\330\004\016\210a\330\004\021\220\026\220r\230\026\230x\240r\250\024\250V\2608\2702\270T\300\034\310[\320Xe\320er\320rs\320s\177\360\000\000@\002A\002\360\000\000A\002P\002\360\000\000P\002Q\002\360\000\000Q\002R\002\330\004\025\220Q\220i\230q\330\004\013\2101";
+static const char __pyx_k_a_aq_T_q_8_T_U_7_A_we_Bl_q_q_4y[] = "\200\001\340%>\270a\360,\000\005\014\210;\220a\220q\330\004\r\210T\220\026\220q\230\001\330\004\r\210]\230!\2308\240:\250T\260\021\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033,\250B\250l\270!\330\004\016\320\016\037\230q\240\010\250\001\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\030\230\022\2304\230y\250\013\2604\260v\270Q\270i\300|\320S_\320_`\320`l\320lm\320m|\360\000\000}\001H\002\360\000\000H\002O\002\360\000\000O\002U\002\360\000\000U\002V\002\360\000\000V\002a\002\360\000\000a\002l\002\360\000\000l\002s\002\360\000\000s\002y\002\360\000\000y\002z\002\360\000\000z\002{\002\330\004\025\220Q\220k\240\021\330\004\013\210:\220Q";
+static const char __pyx_k_aq_6_8_T_6_U_7_A_we_1_q_i_fAYkQ[] = "\200\001\360(\000\005\014\210;\220a\220q\330\004\r\210[\230\001\230\021\330\004\r\210]\230!\2306\240\021\330\004\r\210]\230!\2308\240:\250T\260\030\270\032\3006\310\021\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033+\2501\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\027\230\002\230$\230i\240{\260$\260f\270A\270Y\300k\320QW\320W]\320]^\320^g\320gh\320ht\320tu\360\000\000v\001E\002\360\000\000E\002P\002\360\000\000P\002W\002\360\000\000W\002]\002\360\000\000]\002^\002\360\000\000^\002_\002\330\004\025\220Q\220j\240\001\330\004\013\2101";
+static const char __pyx_k_aq_Q_6_6_a_fHBd_n_iijjyyzz_Qj_1[] = "\200\001\360*\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\r\210[\230\001\230\021\330\004\022\220)\2306\240\021\330\004\r\210]\230!\2306\240\021\330\004\016\210a\330\004\021\220\027\230\002\230&\240\010\250\002\250$\250f\260H\270B\270d\300,\310n\320\\]\320]i\320ij\320jy\320yz\320z{\330\004\025\220Q\220j\240\001\330\004\013\2101";
+static const char __pyx_k_aq_Q_Qa_y_1_6_a_RvXRt6_4_S___kk[] = "\200\001\360(\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\n\210+\220Q\220a\330\004\017\210y\230\003\2301\330\004\r\210]\230!\2306\240\021\330\004\016\210a\330\004\021\220\034\230R\230v\240X\250R\250t\2606\270\030\300\022\3004\300|\320S^\320^_\320_k\320kl\320l{\320{|\320|}\330\004\025\220Q\220o\240Q\330\004\013\2101";
+static const char __pyx_k_aq_Q_Qa_y_1_Kq_q_6_a_a_2V82T_xr[] = "\200\001\360*\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\n\210+\220Q\220a\330\004\017\210y\230\003\2301\330\004\014\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\r\210]\230!\2306\240\025\240a\330\004\016\210a\330\004\021\220\032\2302\230V\2408\2502\250T\260\026\260x\270r\300\024\300\\\320Q\\\320\\i\320ij\320jv\320vw\360\000\000x\001G\002\360\000\000G\002H\002\360\000\000H\002I\002\330\004\025\220Q\220m\2401\330\004\013\2101";
+static const char __pyx_k_aq_Q_Qa_y_1_Kq_q_6_a_a_RvXRt6_4[] = "\200\001\360*\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\n\210+\220Q\220a\330\004\017\210y\230\003\2301\330\004\014\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\r\210]\230!\2306\240\025\240a\330\004\016\210a\330\004\021\220\034\230R\230v\240X\250R\250t\2606\270\030\300\022\3004\300|\320S^\320^k\320kl\320lx\320xy\360\000\000z\001I\002\360\000\000I\002J\002\360\000\000J\002K\002\330\004\025\220Q\220o\240Q\330\004\013\2101";
+static const char __pyx_k_aq_Q_T_q_6_4vXRt_WXXddeettuuv_Q[] = "\200\001\360&\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\r\210T\220\026\220q\230\001\330\004\021\220\021\330\004\021\320\021!\240\022\2406\250\030\260\022\2604\260v\270X\300R\300t\310<\320WX\320Xd\320de\320et\320tu\320uv\330\004\025\220Q\320\026)\250\021\330\004\013\2101";
+static const char __pyx_k_aq_Q_T_q_A_b_hb_F_D_TUUaabbqqrr[] = "\200\001\360*\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\r\210T\220\026\220q\230\001\330\004\021\220\021\330\004\024\220A\330\004\021\220\035\230b\240\006\240h\250b\260\004\260F\270(\300\"\300D\310\014\320TU\320Ua\320ab\320bq\320qr\320r\177\360\000\000@\002A\002\360\000\000A\002B\002\330\004\025\220Q\320\026&\240a\330\004\013\210=\230\001";
+static const char __pyx_k_aq_Q_T_q_a_2V82T_xr_Q___kkll_Qm[] = "\200\001\340./\360&\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\r\210T\220\026\220q\230\001\330\004\016\210a\330\004\021\220\032\2302\230V\2408\2502\250T\260\026\260x\270r\300\024\300\\\320Q^\320^_\320_k\320kl\320l{\320{|\320|}\330\004\025\220Q\220m\2401\330\004\013\2101";
+static const char __pyx_k_aq_Q_T_q_a_6_4vXRt_WXXddeettuuv[] = "\200\001\360&\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\r\210T\220\026\220q\230\001\330\004\016\210a\330\004\021\320\021!\240\022\2406\250\030\260\022\2604\260v\270X\300R\300t\310<\320WX\320Xd\320de\320et\320tu\320uv\330\004\025\220Q\320\026)\250\021\330\004\013\2101";
+static const char __pyx_k_aq_Q_T_q_a_F_D_hb_LPQQ_mmnno_Ql[] = "\200\001\360&\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\r\210T\220\026\220q\230\001\330\004\016\210a\330\004\021\220\031\230\"\230F\240(\250\"\250D\260\006\260h\270b\300\004\300L\320PQ\320Q]\320]^\320^m\320mn\320no\330\004\025\220Q\220l\240!\330\004\013\2101";
+static const char __pyx_k_aq_Q_T_q_a_r_xr_V82T_UVVbbccrrs[] = "\200\001\360&\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\r\210T\220\026\220q\230\001\330\004\016\210a\330\004\021\220\036\230r\240\026\240x\250r\260\024\260V\2708\3002\300T\310\034\320UV\320Vb\320bc\320cr\320rs\320st\330\004\025\220Q\320\026'\240q\330\004\013\2101";
+static const char __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_2V82[] = "\200\001\360,\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\013\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\n\210+\220Q\220a\330\004\017\210y\230\003\2301\330\004\014\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\r\210]\230!\2306\240\026\240u\250A\330\004\021\220\021\330\004\021\320\021#\2402\240V\2508\2602\260T\270\026\270x\300r\310\024\310\\\320Ye\320ep\320p}\320}~\360\000\000\177\001K\002\360\000\000K\002L\002\360\000\000L\002[\002\360\000\000[\002\\\002\360\000\000\\\002]\002\330\004\025\220Q\320\026+\2501\330\004\013\2101";
+static const char __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_6_4v[] = "\200\001\360,\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\013\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\n\210+\220Q\220a\330\004\017\210y\230\003\2301\330\004\014\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\r\210]\230!\2306\240\026\240u\250A\330\004\021\220\021\330\004\021\320\021!\240\022\2406\250\030\260\022\2604\260v\270X\300R\300t\310<\320Wc\320cn\320n{\320{|\360\000\000}\001I\002\360\000\000I\002J\002\360\000\000J\002Y\002\360\000\000Y\002Z\002\360\000\000Z\002[\002\330\004\025\220Q\320\026)\250\021\330\004\013\2101";
+static const char __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_BfHB[] = "\200\001\360,\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\013\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\n\210+\220Q\220a\330\004\017\210y\230\003\2301\330\004\014\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\r\210]\230!\2306\240\026\240u\250A\330\004\021\220\021\330\004\021\320\021$\240B\240f\250H\260B\260d\270&\300\010\310\002\310$\310l\320Zf\320fq\320q~\320~\177\360\000\000@\002L\002\360\000\000L\002M\002\360\000\000M\002\\\002\360\000\000\\\002]\002\360\000\000]\002^\002\330\004\025\220Q\320\026,\250A\330\004\013\2101";
+static const char __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_RvXR[] = "\200\001\360,\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\013\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\n\210+\220Q\220a\330\004\017\210y\230\003\2301\330\004\014\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\r\210]\230!\2306\240\026\240u\250A\330\004\021\220\021\330\004\021\320\021%\240R\240v\250X\260R\260t\2706\300\030\310\022\3104\310|\320[g\320gr\320r\177\360\000\000@\002A\002\360\000\000A\002M\002\360\000\000M\002N\002\360\000\000N\002]\002\360\000\000]\002^\002\360\000\000^\002_\002\330\004\025\220Q\320\026-\250Q\330\004\013\2101";
+static const char __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_a_Rv[] = "\200\001\360,\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\013\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\n\210+\220Q\220a\330\004\017\210y\230\003\2301\330\004\014\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\r\210]\230!\2306\240\026\240u\250A\330\004\016\210a\330\004\021\220\034\230R\230v\240X\250R\250t\2606\270\030\300\022\3004\300|\320S_\320_j\320jw\320wx\360\000\000y\001E\002\360\000\000E\002F\002\360\000\000F\002U\002\360\000\000U\002V\002\360\000\000V\002W\002\330\004\025\220Q\220o\240Q\330\004\013\2101";
+static const char __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_a_fH[] = "\200\001\360,\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\013\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\n\210+\220Q\220a\330\004\017\210y\230\003\2301\330\004\014\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\r\210]\230!\2306\240\026\240u\250A\330\004\016\210a\330\004\021\220\027\230\002\230&\240\010\250\002\250$\250f\260H\270B\270d\300,\310l\320Ze\320er\320rs\320s\177\360\000\000@\002A\002\360\000\000A\002P\002\360\000\000P\002Q\002\360\000\000Q\002R\002\330\004\025\220Q\220j\240\001\330\004\013\2101";
+static const char __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_b_hb[] = "\200\001\360,\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\013\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\n\210+\220Q\220a\330\004\017\210y\230\003\2301\330\004\014\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\r\210]\230!\2306\240\026\240u\250A\330\004\021\220\021\330\004\021\220\035\230b\240\006\240h\250b\260\004\260F\270(\300\"\300D\310\014\320T`\320`k\320kx\320xy\360\000\000z\001F\002\360\000\000F\002G\002\360\000\000G\002V\002\360\000\000V\002W\002\360\000\000W\002X\002\330\004\025\220Q\320\026&\240a\330\004\013\2101";
+static const char __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_fHBd[] = "\200\001\360,\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\013\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\n\210+\220Q\220a\330\004\017\210y\230\003\2301\330\004\014\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\r\210]\230!\2306\240\026\240u\250A\330\004\021\220\021\330\004\021\220\037\240\002\240&\250\010\260\002\260$\260f\270H\300B\300d\310,\320Vb\320bm\320mz\320z{\360\000\000|\001H\002\360\000\000H\002I\002\360\000\000I\002X\002\360\000\000X\002Y\002\360\000\000Y\002Z\002\330\004\025\220Q\320\026(\250\001\330\004\013\2101";
+static const char __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_r_xr[] = "\200\001\360,\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\013\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\n\210+\220Q\220a\330\004\017\210y\230\003\2301\330\004\014\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\r\210]\230!\2306\240\026\240u\250A\330\004\021\220\021\330\004\021\220\036\230r\240\026\240x\250r\260\024\260V\2708\3002\300T\310\034\320Ua\320al\320ly\320yz\360\000\000{\001G\002\360\000\000G\002H\002\360\000\000H\002W\002\360\000\000W\002X\002\360\000\000X\002Y\002\330\004\025\220Q\320\026'\240q\330\004\013\2101";
+static const char __pyx_k_aq_Qa_6_8_T_3a_U_7_A_we_0_q_Rt9[] = "\200\001\360&\000\005\014\210;\220a\220q\330\004\n\210+\220Q\220a\330\004\r\210]\230!\2306\240\021\330\004\r\210]\230!\2308\240:\250T\260\030\270\032\3003\300a\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\0330\260\001\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\034\230R\230t\2409\250K\260t\2706\300\021\300)\310;\320VY\320Y_\320_`\320`i\320ij\320jv\320vw\360\000\000x\001G\002\360\000\000G\002R\002\360\000\000R\002Y\002\360\000\000Y\002_\002\360\000\000_\002`\002\360\000\000`\002a\002\330\004\025\220Q\220o\240Q\330\004\013\2101";
+static const char __pyx_k_aq_Qa_Kq_6_a_8_T_3hjX_U_7_A_w_2[] = "\200\001\340_`\360&\000\005\014\210;\220a\220q\330\004\n\210+\220Q\220a\330\004\014\210K\220q\230\001\330\004\r\210]\230!\2306\240\025\240a\330\004\r\210]\230!\2308\240:\250T\260\030\270\032\3003\300h\310j\320X]\320]^\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\0330\260\002\260!\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\034\230R\230t\2409\250K\260t\2706\300\021\300)\310;\320VY\320Y_\320_`\320`i\320it\320ty\320y\177\360\000\000@\002A\002\360\000\000A\002J\002\360\000\000J\002W\002\360\000\000W\002X\002\360\000\000X\002d\002\360\000\000d\002e\002\360\000\000e\002t\002\360\000\000t\002\177\002\360\000\000\177\002F\003\360\000\000F\003L\003\360\000\000L\003M\003\360\000\000M\003N\003\330\004\025\220Q\220o\240Q\330\004\013\2101";
+static const char __pyx_k_aq_Qa_Kq_6_a_8_T_3hjX_U_7_A_w_3[] = "\200\001\340^_\360&\000\005\014\210;\220a\220q\330\004\n\210+\220Q\220a\330\004\014\210K\220q\230\001\330\004\r\210]\230!\2306\240\025\240a\330\004\r\210]\230!\2308\240:\250T\260\030\270\032\3003\300h\310j\320X]\320]^\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033/\250r\260\021\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\033\230B\230d\240)\250;\260d\270&\300\001\300\031\310+\320UX\320X^\320^_\320_h\320hs\320sx\320x~\320~\177\360\000\000@\002I\002\360\000\000I\002V\002\360\000\000V\002W\002\360\000\000W\002c\002\360\000\000c\002d\002\360\000\000d\002s\002\360\000\000s\002~\002\360\000\000~\002E\003\360\000\000E\003K\003\360\000\000K\003L\003\360\000\000L\003M\003\330\004\025\220Q\220n\240A\330\004\013\2101";
+static const char __pyx_k_aq_T_q_8_T_U_7_A_we_1_1_q_b_I_F[] = "\200\001\340*+\360&\000\005\014\210;\220a\220q\330\004\r\210T\220\026\220q\230\001\330\004\r\210]\230!\2308\240:\250T\260\021\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\0331\260\022\2601\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\035\230b\240\004\240I\250[\270\004\270F\300!\3009\310M\320YZ\320Zf\320fg\320gv\360\000\000w\001B\002\360\000\000B\002I\002\360\000\000I\002O\002\360\000\000O\002P\002\360\000\000P\002Q\002\330\004\025\220Q\320\026&\240a\330\004\013\2101";
+static const char __pyx_k_aq_T_q_8_T_U_7_A_we_2Q_q_i_fAYm[] = "\200\001\340$%\360&\000\005\014\210;\220a\220q\330\004\r\210T\220\026\220q\230\001\330\004\r\210]\230!\2308\240:\250T\260\021\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033+\2502\250Q\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\027\230\002\230$\230i\240{\260$\260f\270A\270Y\300m\320ST\320T`\320`a\320ap\320p{\360\000\000|\001C\002\360\000\000C\002I\002\360\000\000I\002J\002\360\000\000J\002K\002\330\004\025\220Q\220j\240\001\330\004\013\2101";
+static const char __pyx_k_aq_T_q_8_T_U_7_A_we_2_q_r_Yk_V1[] = "\200\001\360&\000\005\014\210;\220a\220q\330\004\r\210T\220\026\220q\230\001\330\004\r\210]\230!\2308\240:\250T\260\021\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\0332\260!\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\036\230r\240\024\240Y\250k\270\024\270V\3001\300I\310Q\310l\320Z[\320[j\320ju\320u|\360\000\000}\001C\002\360\000\000C\002D\002\360\000\000D\002E\002\330\004\025\220Q\320\026'\240q\330\004\013\2101";
+static const char __pyx_k_aq_T_q_8_T_U_7_A_we_31_q_i_fAYa[] = "\200\001\360&\000\005\014\210;\220a\220q\330\004\r\210T\220\026\220q\230\001\330\004\r\210]\230!\2308\240:\250T\260\021\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\0333\2601\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\037\240\002\240$\240i\250{\270$\270f\300A\300Y\310a\310|\320[\\\320\\k\320kv\320v}\360\000\000~\001D\002\360\000\000D\002E\002\360\000\000E\002F\002\330\004\025\220Q\320\026(\250\001\330\004\013\2101";
+static const char __pyx_k_aq_T_q_8_T_U_7_A_we_32Q_axq_axq[] = "\200\001\340,-\360*\000\005\014\210;\220a\220q\330\004\r\210T\220\026\220q\230\001\330\004\r\210]\230!\2308\240:\250T\260\021\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\0333\2602\260Q\330\004\020\220\016\230a\230x\240q\330\004\020\220\016\230a\230x\240q\330\004\021\220\037\240\002\240$\240i\250{\270$\270f\300A\300Y\310m\320[\\\320\\h\320hi\320ix\360\000\000y\001A\002\360\000\000A\002J\002\360\000\000J\002P\002\360\000\000P\002Q\002\360\000\000Q\002\\\002\360\000\000\\\002d\002\360\000\000d\002m\002\360\000\000m\002s\002\360\000\000s\002t\002\360\000\000t\002u\002\330\004\025\220Q\320\026(\250\001\330\004\025\220V\2309\240A\330\004\010\210\007\320\017\037\230q\330\010\026\220a\220v\230Q\330\004\025\220V\2309\240A\330\004\010\210\007\320\017\037\230q\330\010\026\220a\220v\230Q\330\004\013\210<\220q";
+static const char __pyx_k_aq_T_q_8_T_U_7_A_we_4A_q_4y_4vQ[] = "\200\001\360&\000\005\014\210;\220a\220q\330\004\r\210T\220\026\220q\230\001\330\004\r\210]\230!\2308\240:\250T\260\021\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\0334\260A\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\320\021!\240\022\2404\240y\260\013\2704\270v\300Q\300i\310q\320P\\\320\\]\320]l\320lw\320w~\360\000\000\177\001E\002\360\000\000E\002F\002\360\000\000F\002G\002\330\004\025\220Q\320\026)\250\021\330\004\013\2101";
+static const char __pyx_k_aq_T_q_8_T_U_7_A_we_A_q_4y_4vQi[] = "\200\001\360&\000\005\014\210;\220a\220q\330\004\r\210T\220\026\220q\230\001\330\004\r\210]\230!\2308\240:\250T\260\021\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033,\250A\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\030\230\022\2304\230y\250\013\2604\260v\270Q\270i\300q\310\014\320TU\320Ud\320do\320ov\320v|\320|}\320}~\330\004\025\220Q\220k\240\021\330\004\013\2101";
+static const char __pyx_k_aq_T_q_8_T_U_7_A_we_Ba_q_4y_4vQ[] = "\200\001\340%&\360&\000\005\014\210;\220a\220q\330\004\r\210T\220\026\220q\230\001\330\004\r\210]\230!\2308\240:\250T\260\021\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033,\250B\250a\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\030\230\022\2304\230y\250\013\2604\260v\270Q\270i\300}\320TU\320Ua\320ab\320bq\320q|\360\000\000}\001D\002\360\000\000D\002J\002\360\000\000J\002K\002\360\000\000K\002L\002\330\004\025\220Q\220k\240\021\330\004\013\2101";
+static const char __pyx_k_aq_T_q_8_T_U_7_A_we_Rq_q_D_D_ay[] = "\200\001\340&'\360&\000\005\014\210;\220a\220q\330\004\r\210T\220\026\220q\230\001\330\004\r\210]\230!\2308\240:\250T\260\021\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033-\250R\250q\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\031\230\"\230D\240\t\250\033\260D\270\006\270a\270y\310\r\320UV\320Vb\320bc\320cr\320r}\360\000\000~\001E\002\360\000\000E\002K\002\360\000\000K\002L\002\360\000\000L\002M\002\330\004\025\220Q\220l\240!\330\004\013\2101";
+static const char __pyx_k_aq_T_q_8_T_U_7_A_we_b_axq_axq_2[] = "\200\001\340'(\360*\000\005\014\210;\220a\220q\330\004\r\210T\220\026\220q\230\001\330\004\r\210]\230!\2308\240:\250T\260\021\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033.\250b\260\001\330\004\r\320\r\036\230a\230x\240q\330\004\r\320\r\036\230a\230x\240q\330\004\021\220\032\2302\230T\240\031\250+\260T\270\026\270q\300\t\310\035\320VW\320Wc\320cd\320ds\320s~\360\000\000\177\001E\002\360\000\000E\002K\002\360\000\000K\002L\002\360\000\000L\002W\002\360\000\000W\002b\002\360\000\000b\002h\002\360\000\000h\002n\002\360\000\000n\002o\002\360\000\000o\002p\002\330\004\025\220Q\220m\2401\330\004\013\2109\220A";
+static const char __pyx_k_aq_T_q_8_T_U_7_A_we_q_r_Yk_V1IQ[] = "\200\001\360&\000\005\014\210;\220a\220q\330\004\r\210T\220\026\220q\230\001\330\004\r\210]\230!\2308\240:\250T\260\021\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\230?\250!\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\026\220r\230\024\230Y\240k\260\024\260V\2701\270I\300Q\300l\320RS\320Sb\320bm\320mt\320tz\320z{\320{|\330\004\025\220Q\220i\230q\330\004\013\2101";
+static const char __pyx_k_aq_T_q_8_T_U_7_A_we_r_q_Bd_d_WX[] = "\200\001\340()\360&\000\005\014\210;\220a\220q\330\004\r\210T\220\026\220q\230\001\330\004\r\210]\230!\2308\240:\250T\260\021\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033/\250r\260\021\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\033\230B\230d\240)\250;\260d\270&\300\001\300\031\310-\320WX\320Xd\320de\320et\320t\177\360\000\000@\002G\002\360\000\000G\002M\002\360\000\000M\002N\002\360\000\000N\002O\002\330\004\025\220Q\220n\240A\330\004\013\2101";
+static const char __pyx_k_aq_T_q_8_T_U_7_A_we_r_q_Qha_1HA[] = "\200\001\340()\360.\000\005\014\210;\220a\220q\330\004\r\210T\220\026\220q\230\001\330\004\r\210]\230!\2308\240:\250T\260\021\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033/\250r\260\021\330\004\016\320\016\037\230q\240\010\250\001\330\004\024\320\024%\240Q\240h\250a\330\004\022\320\022#\2401\240H\250A\330\004\021\220\033\230B\230d\240)\250;\260d\270&\300\001\300\031\310/\320YZ\320Zf\320fg\320gv\360\000\000w\001B\002\360\000\000B\002I\002\360\000\000I\002O\002\360\000\000O\002P\002\360\000\000P\002[\002\360\000\000[\002f\002\360\000\000f\002s\002\360\000\000s\002y\002\360\000\000y\002z\002\360\000\000z\002E\003\360\000\000E\003P\003\360\000\000P\003[\003\360\000\000[\003a\003\360\000\000a\003b\003\360\000\000b\003c\003\330\004\025\220Q\220n\240A\330\004\013\210:\320\025%\240Q";
+static const char __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns[] = "\200\001\360&\000\005\014\210;\220a\220q\330\004\013\210;\220a\220q\330\004\n\210+\220Q\220a\330\004\014\210K\220q\230\001\330\004\r\210]\230!\2306\240\026\240u\250A\330\004\r\210]\230!\2308\240:\250T\260\030\270\032\3004\300x\310z\320Y\\\320\\d\320dn\320ns\320st\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\0330\260\001\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\034\230R\230t\2409\250K\260t\2706\300\021\300)\310;\320VZ\320Z`\320`a\320aj\320ju\320ux\320x~\320~\177\360\000\000@\002I\002\360\000\000I\002T\002\360\000\000T\002Y\002\360\000\000Y\002_\002\360\000\000_\002`\002\360\000\000`\002i\002\360\000\000i\002j\002\360\000\000j\002v\002\360\000\000v\002w\002\360\000\000w\002F\003\360\000\000F\003Q\003\360\000\000Q\003X\003\360\000\000X\003^\003\360\000\000^\003_\003\360\000\000_\003`\003\330\004\025\220Q\220o\240Q\330\004\013\2101";
+static const char __pyx_k_bc_aq_Q_Qa_y_1_Kq_q_6_a_a_6_4vX[] = "\200\001\340bc\360*\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\n\210+\220Q\220a\330\004\017\210y\230\003\2301\330\004\014\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\r\210]\230!\2306\240\025\240a\330\004\016\210a\330\004\021\220\030\230\022\2306\240\030\250\022\2504\250v\260X\270R\270t\300<\310{\320Zg\320gt\320tu\360\000\000v\001B\002\360\000\000B\002C\002\360\000\000C\002R\002\360\000\000R\002S\002\360\000\000S\002T\002\330\004\025\220Q\220k\240\021\330\004\013\2101";
+static const char __pyx_k_c_X_X_m_m_G_G_H_6_aq_Q_Qa_y_1_K[] = "\200\001\340c}\360\000\000~\001X\002\360\000\000X\002m\002\360\000\000m\002G\003\360\000\000G\003H\003\3606\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\n\210+\220Q\220a\330\004\017\210y\230\003\2301\330\004\014\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\r\210]\230!\2306\240\025\240a\330\004\017\210q\330\004\017\210q\330\004\021\220\031\230\"\230F\240(\250\"\250D\260\006\260h\270b\300\004\300L\320P[\320[h\320hw\360\000\000x\001G\002\360\000\000G\002V\002\360\000\000V\002e\002\360\000\000e\002t\002\360\000\000t\002u\002\360\000\000u\002A\003\360\000\000A\003B\003\360\000\000B\003Q\003\360\000\000Q\003R\003\360\000\000R\003]\003\360\000\000]\003^\003\360\000\000^\003_\003\330\004\025\220Q\220l\240!\330\004\013\210;\220a";
+static const char __pyx_k_cd_aq_Q_Qa_y_1_Kq_q_6_a_a_F_D_h[] = "\200\001\340cd\360*\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\n\210+\220Q\220a\330\004\017\210y\230\003\2301\330\004\014\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\r\210]\230!\2306\240\025\240a\330\004\016\210a\330\004\021\220\031\230\"\230F\240(\250\"\250D\260\006\260h\270b\300\004\300L\320P[\320[h\320hu\320uv\360\000\000w\001C\002\360\000\000C\002D\002\360\000\000D\002S\002\360\000\000S\002T\002\360\000\000T\002U\002\330\004\025\220Q\220l\240!\330\004\013\2101";
+static const char __pyx_k_ef_aq_Q_Qa_y_1_Kq_q_6_a_a_BfHBd[] = "\200\001\340ef\360*\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\n\210+\220Q\220a\330\004\017\210y\230\003\2301\330\004\014\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\r\210]\230!\2306\240\025\240a\330\004\016\210a\330\004\021\220\033\230B\230f\240H\250B\250d\260&\270\010\300\002\300$\300l\320R]\320]j\320jw\320wx\360\000\000y\001E\002\360\000\000E\002F\002\360\000\000F\002U\002\360\000\000U\002V\002\360\000\000V\002W\002\330\004\025\220Q\220n\240A\330\004\013\2101";
+static const char __pyx_k_fg2_aq_Q_Qa_y_1_Kq_q_6_a_q_q_Rv[] = "\200\001\340fg\3602\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\n\210+\220Q\220a\330\004\017\210y\230\003\2301\330\004\014\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\r\210]\230!\2306\240\025\240a\330\004\027\220q\330\004\030\230\001\330\004\027\220q\330\004\021\220\034\230R\230v\240X\250R\250t\2606\270\030\300\022\3004\300|\320S^\320^k\320kx\320xy\360\000\000z\001F\002\360\000\000F\002G\002\360\000\000G\002V\002\360\000\000V\002W\002\360\000\000W\002j\002\360\000\000j\002k\002\360\000\000k\002\177\002\360\000\000\177\002@\003\360\000\000@\003A\003\330\004\025\220Q\220o\240Q\330\004\013\320\013\036\320\0362\260!";
+static const char __pyx_k_fg_aq_Q_Qa_y_1_Kq_q_6_a_a_RvXRt[] = "\200\001\340fg\360*\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\n\210+\220Q\220a\330\004\017\210y\230\003\2301\330\004\014\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\r\210]\230!\2306\240\025\240a\330\004\016\210a\330\004\021\220\034\230R\230v\240X\250R\250t\2606\270\030\300\022\3004\300|\320S^\320^k\320kx\320xy\360\000\000z\001F\002\360\000\000F\002G\002\360\000\000G\002V\002\360\000\000V\002W\002\360\000\000W\002X\002\330\004\025\220Q\220o\240Q\330\004\013\2101";
+static const char __pyx_k_function_failed_with_error_code[] = " function failed with error code ";
 static const char __pyx_k_integer_values_are_100_0_or_100[] = "integer (values are -100, 0 or 100)";
-static const char __pyx_k_numpy_core_multiarray_failed_to[] = "numpy.core.multiarray failed to import";
-static const char __pyx_k_s_function_failed_with_error_co[] = "%s function failed with error code %s: %s";
 static const char __pyx_k_ta_restore_candle_default_setti[] = "_ta_restore_candle_default_settings";
-static const char __pyx_k_unknown_dtype_code_in_numpy_pxd[] = "unknown dtype code in numpy.pxd (%d)";
+static const char __pyx_k_v_w_P_P_Q_aq_Qa_Kq_6_a_8_T_3hjX[] = "\200\001\340]v\360\000\000w\001P\002\360\000\000P\002Q\002\360*\000\005\014\210;\220a\220q\330\004\n\210+\220Q\220a\330\004\014\210K\220q\230\001\330\004\r\210]\230!\2306\240\025\240a\330\004\r\210]\230!\2308\240:\250T\260\030\270\032\3003\300h\310j\320X]\320]^\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033.\250b\260\016\270n\310A\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\032\2302\230T\240\031\250+\260T\270\026\270q\300\t\310\033\320TW\320W]\320]^\320^g\320gr\320rw\320w}\320}~\360\000\000\177\001H\002\360\000\000H\002V\002\360\000\000V\002d\002\360\000\000d\002r\002\360\000\000r\002s\002\360\000\000s\002\177\002\360\000\000\177\002@\003\360\000\000@\003O\003\360\000\000O\003Z\003\360\000\000Z\003a\003\360\000\000a\003g\003\360\000\000g\003h\003\360\000\000h\003i\003\330\004\025\220Q\220m\2401\330\004\013\2101";
+static const char __pyx_k_w_x_R_R_S_aq_Qa_Kq_6_a_8_T_3hjX[] = "\200\001\340]w\360\000\000x\001R\002\360\000\000R\002S\002\360.\000\005\014\210;\220a\220q\330\004\n\210+\220Q\220a\330\004\014\210K\220q\230\001\330\004\r\210]\230!\2306\240\025\240a\330\004\r\210]\230!\2308\240:\250T\260\030\270\032\3003\300h\310j\320X]\320]^\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033.\250b\260\017\270\177\310a\330\004\017\320\017 \240\001\240\030\250\021\330\004\017\320\017 \240\001\240\030\250\021\330\004\021\220\032\2302\230T\240\031\250+\260T\270\026\270q\300\t\310\033\320TW\320W]\320]^\320^g\320gr\320rw\320w}\320}~\360\000\000\177\001H\002\360\000\000H\002W\002\360\000\000W\002f\002\360\000\000f\002u\002\360\000\000u\002v\002\360\000\000v\002B\003\360\000\000B\003C\003\360\000\000C\003R\003\360\000\000R\003]\003\360\000\000]\003e\003\360\000\000e\003k\003\360\000\000k\003l\003\360\000\000l\003w\003\360\000\000w\003B\004\360\000\000B\004J\004\360\000\000J\004P\004\360\000\000P\004Q\004\360\000\000Q\004R\004\330\004\025\220Q\220m\2401\330\004\013\210;\220a";
+static const char __pyx_k_wx_aq_Qa_Kq_6_gQ_8_T_3hjX_eeoou[] = "\200\001\340wx\360&\000\005\014\210;\220a\220q\330\004\n\210+\220Q\220a\330\004\014\210K\220q\230\001\330\004\r\210[\230\001\230\021\330\004\r\210]\230!\2306\240\025\240g\250Q\330\004\r\210]\230!\2308\240:\250T\260\030\270\032\3003\300h\310j\320X]\320]e\320eo\320ou\320uv\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033+\2502\250Q\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\027\230\002\230$\230i\240{\260$\260f\270A\270Y\300k\320QT\320TZ\320Z[\320[d\320do\320ot\320tz\320z{\360\000\000|\001E\002\360\000\000E\002P\002\360\000\000P\002V\002\360\000\000V\002\\\002\360\000\000\\\002]\002\360\000\000]\002f\002\360\000\000f\002s\002\360\000\000s\002t\002\360\000\000t\002@\003\360\000\000@\003A\003\360\000\000A\003P\003\360\000\000P\003[\003\360\000\000[\003b\003\360\000\000b\003h\003\360\000\000h\003i\003\360\000\000i\003j\003\330\004\025\220Q\220j\240\001\330\004\013\2101";
+static const char __pyx_k_y_1_q_Q_a_Q_a_Q_a_Q_a_Q_a_Q_a_Q[] = "\200\001\330\004\007\200y\220\003\2201\330\010\017\210q\330\t\022\220#\220Q\330\010\026\220a\330\t\022\220#\220Q\330\010\026\220a\330\t\022\220#\220Q\330\010\026\220a\330\t\022\220#\220Q\330\010\026\220a\330\t\022\220#\220Q\330\010\026\220a\330\t\022\220#\220Q\330\010\026\220a\330\t\022\220#\220Q\330\010\026\220a\330\t\022\220#\220Q\330\010\026\220a\330\t\022\220#\220Q\330\010\026\220a\330\t\022\220#\220Q\330\010\026\220a\330\t\022\220#\220Q\330\010\026\220a\330\t\022\220#\220Q\330\010\026\220a\330\t\022\220#\220Q\330\010\026\220a\330\t\022\220#\220Q\330\010\026\220a\330\t\022\220#\220Q\330\010\026\220a\330\t\022\220#\220Q\330\010\026\220a\330\t\022\220#\220Q\330\010\026\220a\330\t\022\220#\220Q\330\010\026\220a\340\010\026\220a\330\004\n\210)\2201\220A\330\010\027\220z\240\021";
+static const char __pyx_k_1_aq_T_q_8_T_U_7_A_we_M_q_r_Yk_2[] = "\200\001\340#;\2701\360(\000\005\014\210;\220a\220q\330\004\r\210T\220\026\220q\230\001\330\004\r\210]\230!\2308\240:\250T\260\021\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\230?\250\"\250M\270\021\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\026\220r\230\024\230Y\240k\260\024\260V\2701\270I\300]\320R\\\320\\]\320]i\320ij\320jy\360\000\000z\001E\002\360\000\000E\002L\002\360\000\000L\002R\002\360\000\000R\002S\002\360\000\000S\002T\002\330\004\025\220Q\220i\230q\330\004\013\2101";
+static const char __pyx_k_A2_A_QnA_1_t_6a_gQ_d_Q_d_1_q_s_A[] = "\200A\3602\000\t\021\220\004\220A\330\010\013\210:\220Q\220n\240A\330\014\033\2301\330\014\020\220\007\220t\320\0336\260a\330\020\023\320\023&\240g\250Q\330\024\030\230\n\240!\240>\260\021\330\024\036\230d\240'\250\034\260Q\340\024\036\230d\240'\250\021\330\020\023\2201\330\024 \240\007\240q\250\001\330\014\017\210s\220!\220>\240\023\240A\330\020\025\320\025%\240Q\330\020\025\320\025&\240a\330\020\027\220q\340\020\026\220i\230q\240\001\330/6\260c\270\021\270.\310\002\310!\3309:\33004\260E\270\021\270!\330\010\017\210q";
+static const char __pyx_k_A_A_4_B_q_A_U_q_we1_axq_wgQa_Q_a[] = "\200A\330\010\020\220\004\220A\330\010#\2404\320'B\300!\360\006\000\t\020\210q\330\010\014\320\014\034\230A\330\014\025\220U\230-\240q\250\001\330\014\017\320\017\037\230w\240e\2501\330\024\036\230a\230x\240q\330\020\031\230\026\230w\240g\250Q\250a\330\021!\240\027\250\005\250Q\330\024\036\230a\230x\240q\330\020\031\230\026\230y\250\002\250'\260\021\260!\330\014\020\220\007\220q\230\001\330\010\014\210M\230\025\230a\330\014\024\220D\320\030.\250a\250q\330\014\020\220\007\220q\230\001\360\006\000\t\023\220$\220l\240\"\240A\330\010\013\210:\220Q\220k\240\021\330\014\023\2205\230\010\240\005\240Q\330\014\017\210t\220:\230Q\230f\240A\330\020\027\220t\2301\230A\330\014\021\220\030\230\021\230$\230a\230v\240Q\340\014\020\220\003\220:\230Y\240a\240u\250A\330\020\025\220X\230Q\230j\250\007\250q\260\001\330\010\r\320\r\036\230a";
+static const char __pyx_k_A_A_4uA_e87_4z_q_aq_gU_5_q_E_a_s[] = "\200A\360\016\000\t\021\220\004\220A\330\010\013\2104\210u\220A\330\014\020\320\020 \240\001\330\010\016\210e\2208\2307\240!\330\010\013\2104\210z\230\021\230%\230q\330\014\022\220$\220a\220q\330\010\013\320\013\036\230g\240U\250!\330\020\032\230!\2305\240\017\250q\330\014\024\220E\230\035\240a\330\014\017\210s\220!\2205\230\003\2301\330\020\027\220\177\240a\240s\250!\2504\250v\260Q\340\020\027\320\027)\250\021\250%\250}\270A\270Q\330*0\260\001\330*2\260$\260a\330\r \240\007\240u\250A\330\020\032\230!\2305\240\017\250q\330\014\017\210s\220!\2205\230\003\2301\330\020\027\220\177\240a\240s\250!\2501\340\020\027\320\027)\250\021\250%\250}\270A\270Q\330*1\260\024\260Q\340\014\023\2203\220a\220v\230S\240\001\240\025\240c\250\027\260\001";
+static const char __pyx_k_A_A_at1_C_IQe1_D_aq_E_AZq_vV_2_V[] = "\200A\360\014\000\t\021\220\004\220A\340\010\021\320\021&\240a\240t\2501\330\010\014\210C\210}\230I\240Q\240e\2501\330\014\024\220D\320\030.\250a\250q\330\014\024\220E\230\033\240A\240Z\250q\260\001\330\014\017\210v\220V\320\0332\260#\260V\2706\300\021\330\020)\250\021\250(\260#\260Q\330\021\027\220v\320\0357\260s\270&\300\006\300a\330\020,\250A\250X\260S\270\001\340\010\023\320\023#\2401\240A\330\010\034\230A\230Q\330\010\017\210q";
+static const char __pyx_k_A_HKq_1A_6_5Q_A_7_4A_A_QgQ_7_1_A[] = "\200A\330\010\020\220\004\220H\230K\240q\250\013\2601\260A\330\010\013\2106\220\027\320\0305\260Q\330\014\024\220A\330\r\023\2207\320\0324\260A\330\014\024\220A\340\010\013\210:\220Q\220g\230Q\330\013\022\220!\330\r\023\2207\230!\330\014\022\220)\2301\330\020\021\330\024 \240\005\240[\260\004\260A\260V\2701\330\010\017\210q";
 static const char __pyx_k_Bull_Bear_Pattern_Bearish_0_Neut[] = "Bull/Bear Pattern (Bearish < 0, Neutral = 0, Bullish > 0)";
 static const char __pyx_k_Double_Exponential_Moving_Averag[] = "Double Exponential Moving Average";
-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_Function_Not_Found_TA_FUNC_NOT_F[] = "Function Not Found (TA_FUNC_NOT_FOUND)";
 static const char __pyx_k_Function___check_opt_input_value[] = "Function.__check_opt_input_value";
-static const char __pyx_k_Function___initialize_function_i[] = "Function.__initialize_function_info";
 static const char __pyx_k_Function___input_price_series_na[] = "Function.__input_price_series_names";
 static const char __pyx_k_Group_Not_Found_TA_GROUP_NOT_FOU[] = "Group Not Found (TA_GROUP_NOT_FOUND)";
 static const char __pyx_k_Input_Not_All_Initialized_TA_INP[] = "Input Not All Initialized (TA_INPUT_NOT_ALL_INITIALIZE)";
@@ -2682,929 +3986,44 @@ static const char __pyx_k_Invalid_List_Type_TA_INVALID_LIS[] = "Invalid List Typ
 static const char __pyx_k_Invalid_Parameter_Function_TA_IN[] = "Invalid Parameter Function (TA_INVALID_PARAM_FUNCTION)";
 static const char __pyx_k_Invalid_Parameter_Holder_TA_INVA[] = "Invalid Parameter Holder (TA_INVALID_PARAM_HOLDER)";
 static const char __pyx_k_Invalid_Parameter_Holder_Type_TA[] = "Invalid Parameter Holder Type (TA_INVALID_PARAM_HOLDER_TYPE)";
-static const char __pyx_k_Invalid_parameter_value_for_s_ex[] = "Invalid parameter value for %s (expected %s, got %s)";
 static const char __pyx_k_Library_Not_Initialized_TA_LIB_N[] = "Library Not Initialized (TA_LIB_NOT_INITIALIZE)";
-static const char __pyx_k_Non_native_byte_order_not_suppor[] = "Non-native byte order not supported";
-static const char __pyx_k_Not_enough_price_arguments_expec[] = "Not enough price arguments: expected %d (%s)";
+static const char __pyx_k_Not_enough_price_arguments_expec[] = "Not enough price arguments: expected ";
+static const char __pyx_k_Note_that_Cython_is_deliberately[] = "Note that Cython is deliberately stricter than PEP-484 and rejects subclasses of builtin types. If you need to pass subclasses then set the 'annotation_typing' directive to False.";
 static const char __pyx_k_Out_of_Range_End_Index_TA_OUT_OF[] = "Out-of-Range End Index (TA_OUT_OF_RANGE_END_INDEX)";
 static const char __pyx_k_Output_Not_All_Initialized_TA_OU[] = "Output Not All Initialized (TA_OUTPUT_NOT_ALL_INITIALIZE)";
 static const char __pyx_k_Strength_Pattern_200_100_Bearish[] = "Strength Pattern ([-200..-100] = Bearish, [-100..0] = Getting Bearish, 0 = Neutral, [0..100] = Getting Bullish, [100-200] = Bullish)";
-static const char __pyx_k_Too_many_price_arguments_expecte[] = "Too many price arguments: expected %d (%s)";
+static const char __pyx_k_Too_many_price_arguments_expecte[] = "Too many price arguments: expected ";
 static const char __pyx_k_Triple_Exponential_Moving_Averag[] = "Triple Exponential Moving Average";
 static const char __pyx_k_Triple_Generalized_Double_Expone[] = "Triple Generalized Double Exponential Moving Average";
+static const char __pyx_k_aq_Qa_Kq_6_a_8_T_3hjX_U_7_A_we_2[] = "\200\001\360&\000\005\014\210;\220a\220q\330\004\n\210+\220Q\220a\330\004\014\210K\220q\230\001\330\004\r\210]\230!\2306\240\025\240a\330\004\r\210]\230!\2308\240:\250T\260\030\270\032\3003\300h\310j\320X]\320]^\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033.\250a\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\032\2302\230T\240\031\250+\260T\270\026\270q\300\t\310\033\320TW\320W]\320]^\320^g\320gr\320rw\320w}\320}~\360\000\000\177\001H\002\360\000\000H\002I\002\360\000\000I\002U\002\360\000\000U\002V\002\360\000\000V\002e\002\360\000\000e\002p\002\360\000\000p\002w\002\360\000\000w\002}\002\360\000\000}\002~\002\360\000\000~\002\177\002\330\004\025\220Q\220m\2401\330\004\013\2101";
+static const char __pyx_k_aq_Qa_Kq_6_a_8_T_3hjX_U_7_A_we_3[] = "\200\001\360&\000\005\014\210;\220a\220q\330\004\n\210+\220Q\220a\330\004\014\210K\220q\230\001\330\004\r\210]\230!\2306\240\025\240a\330\004\r\210]\230!\2308\240:\250T\260\030\270\032\3003\300h\310j\320X]\320]^\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\0330\260\001\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\034\230R\230t\2409\250K\260t\2706\300\021\300)\310;\320VY\320Y_\320_`\320`i\320it\320ty\320y\177\360\000\000@\002A\002\360\000\000A\002J\002\360\000\000J\002K\002\360\000\000K\002W\002\360\000\000W\002X\002\360\000\000X\002g\002\360\000\000g\002r\002\360\000\000r\002y\002\360\000\000y\002\177\002\360\000\000\177\002@\003\360\000\000@\003A\003\330\004\025\220Q\220o\240Q\330\004\013\2101";
+static const char __pyx_k_aq_Qa_Kq_6_a_8_T_3hjX_U_7_A_we_4[] = "\200\001\340\\]\360&\000\005\014\210;\220a\220q\330\004\n\210+\220Q\220a\330\004\014\210K\220q\230\001\330\004\r\210]\230!\2306\240\025\240a\330\004\r\210]\230!\2308\240:\250T\260\030\270\032\3003\300h\310j\320X]\320]^\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033-\250R\250q\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\031\230\"\230D\240\t\250\033\260D\270\006\270a\270y\310\013\320SV\320V\\\320\\]\320]f\320fq\320qv\320v|\320|}\360\000\000~\001G\002\360\000\000G\002T\002\360\000\000T\002U\002\360\000\000U\002a\002\360\000\000a\002b\002\360\000\000b\002q\002\360\000\000q\002|\002\360\000\000|\002C\003\360\000\000C\003I\003\360\000\000I\003J\003\360\000\000J\003K\003\330\004\025\220Q\220l\240!\330\004\013\2101";
+static const char __pyx_k_aq_T_q_8_T_U_7_A_we_0_q_Rt9Kt6_2[] = "\200\001\340)*\360&\000\005\014\210;\220a\220q\330\004\r\210T\220\026\220q\230\001\330\004\r\210]\230!\2308\240:\250T\260\021\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\0330\260\002\260!\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\034\230R\230t\2409\250K\260t\2706\300\021\300)\310=\320XY\320Ye\320ef\320fu\360\000\000v\001A\002\360\000\000A\002H\002\360\000\000H\002N\002\360\000\000N\002O\002\360\000\000O\002P\002\330\004\025\220Q\220o\240Q\330\004\013\2101";
 static const char __pyx_k_input_array_has_wrong_dimensions[] = "input array has wrong dimensions";
 static const char __pyx_k_input_array_lengths_are_differen[] = "input array lengths are different";
-static const char __pyx_k_input_arrays_parameter_missing_r[] = "input_arrays parameter missing required data key%s: %s";
-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_s_3;
-static PyObject *__pyx_n_s_ACOS;
-static PyObject *__pyx_n_s_AD;
-static PyObject *__pyx_n_s_ADD;
-static PyObject *__pyx_n_s_ADOSC;
-static PyObject *__pyx_n_s_ADX;
-static PyObject *__pyx_n_s_ADXR;
-static PyObject *__pyx_n_s_ALL;
-static PyObject *__pyx_n_s_APO;
-static PyObject *__pyx_n_s_AROON;
-static PyObject *__pyx_n_s_AROONOSC;
-static PyObject *__pyx_n_s_ARRAY_TYPES;
-static PyObject *__pyx_n_s_ASIN;
-static PyObject *__pyx_n_s_ATAN;
-static PyObject *__pyx_n_s_ATR;
-static PyObject *__pyx_n_s_AVGPRICE;
-static PyObject *__pyx_n_s_AllCandleSettings;
-static PyObject *__pyx_kp_s_Allocation_Error_TA_ALLOC_ERR;
-static PyObject *__pyx_n_s_BBANDS;
-static PyObject *__pyx_n_s_BETA;
-static PyObject *__pyx_n_s_BOP;
-static PyObject *__pyx_kp_s_Bad_Object_TA_BAD_OBJECT;
-static PyObject *__pyx_kp_s_Bad_Parameter_TA_BAD_PARAM;
-static PyObject *__pyx_n_s_BodyDoji;
-static PyObject *__pyx_n_s_BodyLong;
-static PyObject *__pyx_n_s_BodyShort;
-static PyObject *__pyx_n_s_BodyVeryLong;
-static PyObject *__pyx_kp_s_Bull_Bear_Pattern_Bearish_0_Neut;
-static PyObject *__pyx_n_s_CCI;
-static PyObject *__pyx_n_s_CDL2CROWS;
-static PyObject *__pyx_n_s_CDL3BLACKCROWS;
-static PyObject *__pyx_n_s_CDL3INSIDE;
-static PyObject *__pyx_n_s_CDL3LINESTRIKE;
-static PyObject *__pyx_n_s_CDL3OUTSIDE;
-static PyObject *__pyx_n_s_CDL3STARSINSOUTH;
-static PyObject *__pyx_n_s_CDL3WHITESOLDIERS;
-static PyObject *__pyx_n_s_CDLABANDONEDBABY;
-static PyObject *__pyx_n_s_CDLADVANCEBLOCK;
-static PyObject *__pyx_n_s_CDLBELTHOLD;
-static PyObject *__pyx_n_s_CDLBREAKAWAY;
-static PyObject *__pyx_n_s_CDLCLOSINGMARUBOZU;
-static PyObject *__pyx_n_s_CDLCONCEALBABYSWALL;
-static PyObject *__pyx_n_s_CDLCOUNTERATTACK;
-static PyObject *__pyx_n_s_CDLDARKCLOUDCOVER;
-static PyObject *__pyx_n_s_CDLDOJI;
-static PyObject *__pyx_n_s_CDLDOJISTAR;
-static PyObject *__pyx_n_s_CDLDRAGONFLYDOJI;
-static PyObject *__pyx_n_s_CDLENGULFING;
-static PyObject *__pyx_n_s_CDLEVENINGDOJISTAR;
-static PyObject *__pyx_n_s_CDLEVENINGSTAR;
-static PyObject *__pyx_n_s_CDLGAPSIDESIDEWHITE;
-static PyObject *__pyx_n_s_CDLGRAVESTONEDOJI;
-static PyObject *__pyx_n_s_CDLHAMMER;
-static PyObject *__pyx_n_s_CDLHANGINGMAN;
-static PyObject *__pyx_n_s_CDLHARAMI;
-static PyObject *__pyx_n_s_CDLHARAMICROSS;
-static PyObject *__pyx_n_s_CDLHIGHWAVE;
-static PyObject *__pyx_n_s_CDLHIKKAKE;
-static PyObject *__pyx_n_s_CDLHIKKAKEMOD;
-static PyObject *__pyx_n_s_CDLHOMINGPIGEON;
-static PyObject *__pyx_n_s_CDLIDENTICAL3CROWS;
-static PyObject *__pyx_n_s_CDLINNECK;
-static PyObject *__pyx_n_s_CDLINVERTEDHAMMER;
-static PyObject *__pyx_n_s_CDLKICKING;
-static PyObject *__pyx_n_s_CDLKICKINGBYLENGTH;
-static PyObject *__pyx_n_s_CDLLADDERBOTTOM;
-static PyObject *__pyx_n_s_CDLLONGLEGGEDDOJI;
-static PyObject *__pyx_n_s_CDLLONGLINE;
-static PyObject *__pyx_n_s_CDLMARUBOZU;
-static PyObject *__pyx_n_s_CDLMATCHINGLOW;
-static PyObject *__pyx_n_s_CDLMATHOLD;
-static PyObject *__pyx_n_s_CDLMORNINGDOJISTAR;
-static PyObject *__pyx_n_s_CDLMORNINGSTAR;
-static PyObject *__pyx_n_s_CDLONNECK;
-static PyObject *__pyx_n_s_CDLPIERCING;
-static PyObject *__pyx_n_s_CDLRICKSHAWMAN;
-static PyObject *__pyx_n_s_CDLRISEFALL3METHODS;
-static PyObject *__pyx_n_s_CDLSEPARATINGLINES;
-static PyObject *__pyx_n_s_CDLSHOOTINGSTAR;
-static PyObject *__pyx_n_s_CDLSHORTLINE;
-static PyObject *__pyx_n_s_CDLSPINNINGTOP;
-static PyObject *__pyx_n_s_CDLSTALLEDPATTERN;
-static PyObject *__pyx_n_s_CDLSTICKSANDWICH;
-static PyObject *__pyx_n_s_CDLTAKURI;
-static PyObject *__pyx_n_s_CDLTASUKIGAP;
-static PyObject *__pyx_n_s_CDLTHRUSTING;
-static PyObject *__pyx_n_s_CDLTRISTAR;
-static PyObject *__pyx_n_s_CDLUNIQUE3RIVER;
-static PyObject *__pyx_n_s_CDLUPSIDEGAP2CROWS;
-static PyObject *__pyx_n_s_CDLXSIDEGAP3METHODS;
-static PyObject *__pyx_n_s_CEIL;
-static PyObject *__pyx_n_s_CMO;
-static PyObject *__pyx_n_s_CORREL;
-static PyObject *__pyx_n_s_COS;
-static PyObject *__pyx_n_s_COSH;
-static PyObject *__pyx_n_s_CandleSettingType;
-static PyObject *__pyx_n_s_DEMA;
-static PyObject *__pyx_n_s_DIV;
-static PyObject *__pyx_n_s_DX;
-static PyObject *__pyx_kp_s_Dashed_Line;
-static PyObject *__pyx_n_s_DataFrame;
-static PyObject *__pyx_n_s_Dot;
-static PyObject *__pyx_kp_s_Dotted_Line;
-static PyObject *__pyx_kp_s_Double_Exponential_Moving_Averag;
-static PyObject *__pyx_n_s_EMA;
-static PyObject *__pyx_n_s_EXP;
-static PyObject *__pyx_n_s_Equal;
-static PyObject *__pyx_kp_s_Exponential_Moving_Average;
-static PyObject *__pyx_n_s_FLOOR;
-static PyObject *__pyx_n_s_Far;
-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_Function;
-static PyObject *__pyx_kp_s_Function_Not_Found_TA_FUNC_NOT_F;
-static PyObject *__pyx_n_s_Function___call;
-static PyObject *__pyx_n_s_Function___call_function;
-static PyObject *__pyx_n_s_Function___check_opt_input_value;
-static PyObject *__pyx_n_s_Function___get_opt_input_value;
-static PyObject *__pyx_n_s_Function___init;
-static PyObject *__pyx_n_s_Function___initialize_function_i;
-static PyObject *__pyx_n_s_Function___input_price_series_na;
-static PyObject *__pyx_n_s_Function___repr;
-static PyObject *__pyx_n_s_Function___str;
-static PyObject *__pyx_n_s_Function___unicode;
-static PyObject *__pyx_n_s_Function__call_function;
-static PyObject *__pyx_n_s_Function__check_opt_input_value;
-static PyObject *__pyx_n_s_Function__get_opt_input_value;
-static PyObject *__pyx_n_s_Function__info;
-static PyObject *__pyx_n_s_Function__initialize_function_i;
-static PyObject *__pyx_n_s_Function__input_arrays;
-static PyObject *__pyx_n_s_Function__input_names;
-static PyObject *__pyx_n_s_Function__input_price_series_na;
-static PyObject *__pyx_n_s_Function__name;
-static PyObject *__pyx_n_s_Function__namestr;
-static PyObject *__pyx_n_s_Function__opt_inputs;
-static PyObject *__pyx_n_s_Function__outputs;
-static PyObject *__pyx_n_s_Function__outputs_valid;
-static PyObject *__pyx_n_s_Function_function_flags;
-static PyObject *__pyx_n_s_Function_get_input_arrays;
-static PyObject *__pyx_n_s_Function_get_input_names;
-static PyObject *__pyx_n_s_Function_get_parameters;
-static PyObject *__pyx_kp_s_Function_has_an_unstable_period;
-static PyObject *__pyx_n_s_Function_info;
-static PyObject *__pyx_n_s_Function_lookback;
-static PyObject *__pyx_n_s_Function_output_flags;
-static PyObject *__pyx_n_s_Function_output_names;
-static PyObject *__pyx_n_s_Function_outputs;
-static PyObject *__pyx_n_s_Function_run;
-static PyObject *__pyx_n_s_Function_set_function_args;
-static PyObject *__pyx_n_s_Function_set_input_arrays;
-static PyObject *__pyx_n_s_Function_set_input_names;
-static PyObject *__pyx_n_s_Function_set_parameters;
-static PyObject *__pyx_kp_s_Group_Not_Found_TA_GROUP_NOT_FOU;
-static PyObject *__pyx_n_s_HT_DCPERIOD;
-static PyObject *__pyx_n_s_HT_DCPHASE;
-static PyObject *__pyx_n_s_HT_PHASOR;
-static PyObject *__pyx_n_s_HT_SINE;
-static PyObject *__pyx_n_s_HT_TRENDLINE;
-static PyObject *__pyx_n_s_HT_TRENDMODE;
-static PyObject *__pyx_n_s_HighLow;
-static PyObject *__pyx_n_s_Histogram;
-static PyObject *__pyx_n_s_INPUT_ARRAYS_DEFAULTS;
-static PyObject *__pyx_n_s_INPUT_ARRAYS_TYPES;
-static PyObject *__pyx_n_s_INPUT_PRICE_SERIES_DEFAULTS;
-static PyObject *__pyx_n_s_ImportError;
-static PyObject *__pyx_n_s_IndexError;
-static PyObject *__pyx_kp_s_Input_Not_All_Initialized_TA_INP;
-static PyObject *__pyx_kp_s_Inputs;
-static PyObject *__pyx_kp_s_Internal_Error_TA_INTERNAL_ERROR;
-static PyObject *__pyx_kp_s_Invalid_Handle_TA_INVALID_HANDLE;
-static PyObject *__pyx_kp_s_Invalid_List_Type_TA_INVALID_LIS;
-static PyObject *__pyx_kp_s_Invalid_Parameter_Function_TA_IN;
-static PyObject *__pyx_kp_s_Invalid_Parameter_Holder_TA_INVA;
-static PyObject *__pyx_kp_s_Invalid_Parameter_Holder_Type_TA;
-static PyObject *__pyx_kp_s_Invalid_parameter_value_for_s_ex;
-static PyObject *__pyx_n_s_KAMA;
-static PyObject *__pyx_kp_s_Kaufman_Adaptive_Moving_Average;
-static PyObject *__pyx_n_s_LINEARREG;
-static PyObject *__pyx_n_s_LINEARREG_ANGLE;
-static PyObject *__pyx_n_s_LINEARREG_INTERCEPT;
-static PyObject *__pyx_n_s_LINEARREG_SLOPE;
-static PyObject *__pyx_n_s_LN;
-static PyObject *__pyx_n_s_LOG10;
-static PyObject *__pyx_kp_s_Library_Not_Initialized_TA_LIB_N;
-static PyObject *__pyx_n_s_Line;
-static PyObject *__pyx_n_s_MA;
-static PyObject *__pyx_n_s_MACD;
-static PyObject *__pyx_n_s_MACDEXT;
-static PyObject *__pyx_n_s_MACDFIX;
-static PyObject *__pyx_n_s_MAMA;
-static PyObject *__pyx_n_s_MAVP;
-static PyObject *__pyx_n_s_MAX;
-static PyObject *__pyx_n_s_MAXINDEX;
-static PyObject *__pyx_n_s_MA_Type;
-static PyObject *__pyx_n_s_MA_Type___getitem;
-static PyObject *__pyx_n_s_MA_Type___init;
-static PyObject *__pyx_n_s_MEDPRICE;
-static PyObject *__pyx_kp_s_MESA_Adaptive_Moving_Average;
-static PyObject *__pyx_n_s_MFI;
-static PyObject *__pyx_n_s_MIDPOINT;
-static PyObject *__pyx_n_s_MIDPRICE;
-static PyObject *__pyx_n_s_MIN;
-static PyObject *__pyx_n_s_MININDEX;
-static PyObject *__pyx_n_s_MINMAX;
-static PyObject *__pyx_n_s_MINMAXINDEX;
-static PyObject *__pyx_n_s_MINUS_DI;
-static PyObject *__pyx_n_s_MINUS_DM;
-static PyObject *__pyx_n_s_MOM;
-static PyObject *__pyx_n_s_MULT;
-static PyObject *__pyx_n_s_NATR;
-static PyObject *__pyx_n_s_NONE;
-static PyObject *__pyx_n_s_Near;
-static PyObject *__pyx_kp_u_Non_native_byte_order_not_suppor;
-static PyObject *__pyx_kp_s_Not_Supported_TA_NOT_SUPPORTED;
-static PyObject *__pyx_kp_s_Not_enough_price_arguments_expec;
-static PyObject *__pyx_n_s_OBV;
-static PyObject *__pyx_n_s_OrderedDict;
-static PyObject *__pyx_kp_s_Out_of_Range_End_Index_TA_OUT_OF;
-static PyObject *__pyx_kp_s_Out_of_Range_Start_Index_TA_OUT;
-static PyObject *__pyx_kp_s_Output_Not_All_Initialized_TA_OU;
-static PyObject *__pyx_kp_s_Output_can_be_negative;
-static PyObject *__pyx_kp_s_Output_can_be_positive;
-static PyObject *__pyx_kp_s_Output_can_be_zero;
-static PyObject *__pyx_kp_s_Output_is_a_candlestick;
-static PyObject *__pyx_kp_s_Output_is_over_volume;
-static PyObject *__pyx_kp_s_Output_scale_same_as_input;
-static PyObject *__pyx_kp_s_Outputs;
-static PyObject *__pyx_n_s_PANDAS_DATAFRAME;
-static PyObject *__pyx_n_s_PANDAS_SERIES;
-static PyObject *__pyx_n_s_PLUS_DI;
-static PyObject *__pyx_n_s_PLUS_DM;
-static PyObject *__pyx_n_s_PPO;
-static PyObject *__pyx_kp_s_Parameters;
-static PyObject *__pyx_kp_s_Pattern_Bool;
-static PyObject *__pyx_n_s_ROC;
-static PyObject *__pyx_n_s_ROCP;
-static PyObject *__pyx_n_s_ROCR;
-static PyObject *__pyx_n_s_ROCR100;
-static PyObject *__pyx_n_s_RSI;
-static PyObject *__pyx_n_s_RangeType;
-static PyObject *__pyx_n_s_RealBody;
-static PyObject *__pyx_n_s_RuntimeError;
-static PyObject *__pyx_n_s_SAR;
-static PyObject *__pyx_n_s_SAREXT;
-static PyObject *__pyx_n_s_SIN;
-static PyObject *__pyx_n_s_SINH;
-static PyObject *__pyx_n_s_SMA;
-static PyObject *__pyx_n_s_SQRT;
-static PyObject *__pyx_n_s_STDDEV;
-static PyObject *__pyx_n_s_STOCH;
-static PyObject *__pyx_n_s_STOCHF;
-static PyObject *__pyx_n_s_STOCHRSI;
-static PyObject *__pyx_n_s_SUB;
-static PyObject *__pyx_n_s_SUM;
-static PyObject *__pyx_n_s_Series;
-static PyObject *__pyx_n_s_ShadowLong;
-static PyObject *__pyx_n_s_ShadowShort;
-static PyObject *__pyx_n_s_ShadowVeryLong;
-static PyObject *__pyx_n_s_ShadowVeryShort;
-static PyObject *__pyx_n_s_Shadows;
-static PyObject *__pyx_kp_s_Simple_Moving_Average;
-static PyObject *__pyx_kp_s_Strength_Pattern_200_100_Bearish;
-static PyObject *__pyx_n_s_T3;
-static PyObject *__pyx_n_s_TAN;
-static PyObject *__pyx_n_s_TANH;
-static PyObject *__pyx_n_s_TA_ACOS;
-static PyObject *__pyx_n_s_TA_AD;
-static PyObject *__pyx_n_s_TA_ADD;
-static PyObject *__pyx_n_s_TA_ADOSC;
-static PyObject *__pyx_n_s_TA_ADX;
-static PyObject *__pyx_n_s_TA_ADXR;
-static PyObject *__pyx_n_s_TA_APO;
-static PyObject *__pyx_n_s_TA_AROON;
-static PyObject *__pyx_n_s_TA_AROONOSC;
-static PyObject *__pyx_n_s_TA_ASIN;
-static PyObject *__pyx_n_s_TA_ATAN;
-static PyObject *__pyx_n_s_TA_ATR;
-static PyObject *__pyx_n_s_TA_AVGPRICE;
-static PyObject *__pyx_n_s_TA_BBANDS;
-static PyObject *__pyx_n_s_TA_BETA;
-static PyObject *__pyx_n_s_TA_BOP;
-static PyObject *__pyx_n_s_TA_CCI;
-static PyObject *__pyx_n_s_TA_CDL2CROWS;
-static PyObject *__pyx_n_s_TA_CDL3BLACKCROWS;
-static PyObject *__pyx_n_s_TA_CDL3INSIDE;
-static PyObject *__pyx_n_s_TA_CDL3LINESTRIKE;
-static PyObject *__pyx_n_s_TA_CDL3OUTSIDE;
-static PyObject *__pyx_n_s_TA_CDL3STARSINSOUTH;
-static PyObject *__pyx_n_s_TA_CDL3WHITESOLDIERS;
-static PyObject *__pyx_n_s_TA_CDLABANDONEDBABY;
-static PyObject *__pyx_n_s_TA_CDLADVANCEBLOCK;
-static PyObject *__pyx_n_s_TA_CDLBELTHOLD;
-static PyObject *__pyx_n_s_TA_CDLBREAKAWAY;
-static PyObject *__pyx_n_s_TA_CDLCLOSINGMARUBOZU;
-static PyObject *__pyx_n_s_TA_CDLCONCEALBABYSWALL;
-static PyObject *__pyx_n_s_TA_CDLCOUNTERATTACK;
-static PyObject *__pyx_n_s_TA_CDLDARKCLOUDCOVER;
-static PyObject *__pyx_n_s_TA_CDLDOJI;
-static PyObject *__pyx_n_s_TA_CDLDOJISTAR;
-static PyObject *__pyx_n_s_TA_CDLDRAGONFLYDOJI;
-static PyObject *__pyx_n_s_TA_CDLENGULFING;
-static PyObject *__pyx_n_s_TA_CDLEVENINGDOJISTAR;
-static PyObject *__pyx_n_s_TA_CDLEVENINGSTAR;
-static PyObject *__pyx_n_s_TA_CDLGAPSIDESIDEWHITE;
-static PyObject *__pyx_n_s_TA_CDLGRAVESTONEDOJI;
-static PyObject *__pyx_n_s_TA_CDLHAMMER;
-static PyObject *__pyx_n_s_TA_CDLHANGINGMAN;
-static PyObject *__pyx_n_s_TA_CDLHARAMI;
-static PyObject *__pyx_n_s_TA_CDLHARAMICROSS;
-static PyObject *__pyx_n_s_TA_CDLHIGHWAVE;
-static PyObject *__pyx_n_s_TA_CDLHIKKAKE;
-static PyObject *__pyx_n_s_TA_CDLHIKKAKEMOD;
-static PyObject *__pyx_n_s_TA_CDLHOMINGPIGEON;
-static PyObject *__pyx_n_s_TA_CDLIDENTICAL3CROWS;
-static PyObject *__pyx_n_s_TA_CDLINNECK;
-static PyObject *__pyx_n_s_TA_CDLINVERTEDHAMMER;
-static PyObject *__pyx_n_s_TA_CDLKICKING;
-static PyObject *__pyx_n_s_TA_CDLKICKINGBYLENGTH;
-static PyObject *__pyx_n_s_TA_CDLLADDERBOTTOM;
-static PyObject *__pyx_n_s_TA_CDLLONGLEGGEDDOJI;
-static PyObject *__pyx_n_s_TA_CDLLONGLINE;
-static PyObject *__pyx_n_s_TA_CDLMARUBOZU;
-static PyObject *__pyx_n_s_TA_CDLMATCHINGLOW;
-static PyObject *__pyx_n_s_TA_CDLMATHOLD;
-static PyObject *__pyx_n_s_TA_CDLMORNINGDOJISTAR;
-static PyObject *__pyx_n_s_TA_CDLMORNINGSTAR;
-static PyObject *__pyx_n_s_TA_CDLONNECK;
-static PyObject *__pyx_n_s_TA_CDLPIERCING;
-static PyObject *__pyx_n_s_TA_CDLRICKSHAWMAN;
-static PyObject *__pyx_n_s_TA_CDLRISEFALL3METHODS;
-static PyObject *__pyx_n_s_TA_CDLSEPARATINGLINES;
-static PyObject *__pyx_n_s_TA_CDLSHOOTINGSTAR;
-static PyObject *__pyx_n_s_TA_CDLSHORTLINE;
-static PyObject *__pyx_n_s_TA_CDLSPINNINGTOP;
-static PyObject *__pyx_n_s_TA_CDLSTALLEDPATTERN;
-static PyObject *__pyx_n_s_TA_CDLSTICKSANDWICH;
-static PyObject *__pyx_n_s_TA_CDLTAKURI;
-static PyObject *__pyx_n_s_TA_CDLTASUKIGAP;
-static PyObject *__pyx_n_s_TA_CDLTHRUSTING;
-static PyObject *__pyx_n_s_TA_CDLTRISTAR;
-static PyObject *__pyx_n_s_TA_CDLUNIQUE3RIVER;
-static PyObject *__pyx_n_s_TA_CDLUPSIDEGAP2CROWS;
-static PyObject *__pyx_n_s_TA_CDLXSIDEGAP3METHODS;
-static PyObject *__pyx_n_s_TA_CEIL;
-static PyObject *__pyx_n_s_TA_CMO;
-static PyObject *__pyx_n_s_TA_CORREL;
-static PyObject *__pyx_n_s_TA_COS;
-static PyObject *__pyx_n_s_TA_COSH;
-static PyObject *__pyx_n_s_TA_DEMA;
-static PyObject *__pyx_n_s_TA_DIV;
-static PyObject *__pyx_n_s_TA_DX;
-static PyObject *__pyx_n_s_TA_EMA;
-static PyObject *__pyx_n_s_TA_EXP;
-static PyObject *__pyx_n_s_TA_FLOOR;
-static PyObject *__pyx_n_s_TA_FUNCTION_NAMES;
-static PyObject *__pyx_n_s_TA_FUNC_FLAGS;
-static PyObject *__pyx_n_s_TA_FuncTableAlloc;
-static PyObject *__pyx_n_s_TA_FuncTableFree;
-static PyObject *__pyx_n_s_TA_GetFuncHandle;
-static PyObject *__pyx_n_s_TA_GetFuncInfo;
-static PyObject *__pyx_n_s_TA_GetInputParameterInfo;
-static PyObject *__pyx_n_s_TA_GetLookback;
-static PyObject *__pyx_n_s_TA_GetOptInputParameterInfo;
-static PyObject *__pyx_n_s_TA_GetOutputParameterInfo;
-static PyObject *__pyx_n_s_TA_GroupTableAlloc;
-static PyObject *__pyx_n_s_TA_GroupTableFree;
-static PyObject *__pyx_n_s_TA_HT_DCPERIOD;
-static PyObject *__pyx_n_s_TA_HT_DCPHASE;
-static PyObject *__pyx_n_s_TA_HT_PHASOR;
-static PyObject *__pyx_n_s_TA_HT_SINE;
-static PyObject *__pyx_n_s_TA_HT_TRENDLINE;
-static PyObject *__pyx_n_s_TA_HT_TRENDMODE;
-static PyObject *__pyx_n_s_TA_INPUT_FLAGS;
-static PyObject *__pyx_n_s_TA_Initialize;
-static PyObject *__pyx_n_s_TA_KAMA;
-static PyObject *__pyx_n_s_TA_LINEARREG;
-static PyObject *__pyx_n_s_TA_LINEARREG_ANGLE;
-static PyObject *__pyx_n_s_TA_LINEARREG_INTERCEPT;
-static PyObject *__pyx_n_s_TA_LINEARREG_SLOPE;
-static PyObject *__pyx_n_s_TA_LN;
-static PyObject *__pyx_n_s_TA_LOG10;
-static PyObject *__pyx_n_s_TA_MA;
-static PyObject *__pyx_n_s_TA_MACD;
-static PyObject *__pyx_n_s_TA_MACDEXT;
-static PyObject *__pyx_n_s_TA_MACDFIX;
-static PyObject *__pyx_n_s_TA_MAMA;
-static PyObject *__pyx_n_s_TA_MAVP;
-static PyObject *__pyx_n_s_TA_MAX;
-static PyObject *__pyx_n_s_TA_MAXINDEX;
-static PyObject *__pyx_n_s_TA_MEDPRICE;
-static PyObject *__pyx_n_s_TA_MFI;
-static PyObject *__pyx_n_s_TA_MIDPOINT;
-static PyObject *__pyx_n_s_TA_MIDPRICE;
-static PyObject *__pyx_n_s_TA_MIN;
-static PyObject *__pyx_n_s_TA_MININDEX;
-static PyObject *__pyx_n_s_TA_MINMAX;
-static PyObject *__pyx_n_s_TA_MINMAXINDEX;
-static PyObject *__pyx_n_s_TA_MINUS_DI;
-static PyObject *__pyx_n_s_TA_MINUS_DM;
-static PyObject *__pyx_n_s_TA_MOM;
-static PyObject *__pyx_n_s_TA_MULT;
-static PyObject *__pyx_n_s_TA_NATR;
-static PyObject *__pyx_n_s_TA_OBV;
-static PyObject *__pyx_n_s_TA_OUTPUT_FLAGS;
-static PyObject *__pyx_n_s_TA_PLUS_DI;
-static PyObject *__pyx_n_s_TA_PLUS_DM;
-static PyObject *__pyx_n_s_TA_PPO;
-static PyObject *__pyx_n_s_TA_ParamHolderAlloc;
-static PyObject *__pyx_n_s_TA_ParamHolderFree;
-static PyObject *__pyx_n_s_TA_ROC;
-static PyObject *__pyx_n_s_TA_ROCP;
-static PyObject *__pyx_n_s_TA_ROCR;
-static PyObject *__pyx_n_s_TA_ROCR100;
-static PyObject *__pyx_n_s_TA_RSI;
-static PyObject *__pyx_n_s_TA_RestoreCandleDefaultSettings;
-static PyObject *__pyx_n_s_TA_SAR;
-static PyObject *__pyx_n_s_TA_SAREXT;
-static PyObject *__pyx_n_s_TA_SIN;
-static PyObject *__pyx_n_s_TA_SINH;
-static PyObject *__pyx_n_s_TA_SMA;
-static PyObject *__pyx_n_s_TA_SQRT;
-static PyObject *__pyx_n_s_TA_STDDEV;
-static PyObject *__pyx_n_s_TA_STOCH;
-static PyObject *__pyx_n_s_TA_STOCHF;
-static PyObject *__pyx_n_s_TA_STOCHRSI;
-static PyObject *__pyx_n_s_TA_SUB;
-static PyObject *__pyx_n_s_TA_SUM;
-static PyObject *__pyx_n_s_TA_SetCandleSettings;
-static PyObject *__pyx_n_s_TA_SetCompatibility;
-static PyObject *__pyx_n_s_TA_SetOptInputParamInteger;
-static PyObject *__pyx_n_s_TA_SetOptInputParamReal;
-static PyObject *__pyx_n_s_TA_SetUnstablePeriod;
-static PyObject *__pyx_n_s_TA_Shutdown;
-static PyObject *__pyx_n_s_TA_T3;
-static PyObject *__pyx_n_s_TA_TAN;
-static PyObject *__pyx_n_s_TA_TANH;
-static PyObject *__pyx_n_s_TA_TEMA;
-static PyObject *__pyx_n_s_TA_TRANGE;
-static PyObject *__pyx_n_s_TA_TRIMA;
-static PyObject *__pyx_n_s_TA_TRIX;
-static PyObject *__pyx_n_s_TA_TSF;
-static PyObject *__pyx_n_s_TA_TYPPRICE;
-static PyObject *__pyx_n_s_TA_ULTOSC;
-static PyObject *__pyx_n_s_TA_VAR;
-static PyObject *__pyx_n_s_TA_WCLPRICE;
-static PyObject *__pyx_n_s_TA_WILLR;
-static PyObject *__pyx_n_s_TA_WMA;
-static PyObject *__pyx_n_s_TEMA;
-static PyObject *__pyx_n_s_TRANGE;
-static PyObject *__pyx_n_s_TRIMA;
-static PyObject *__pyx_n_s_TRIX;
-static PyObject *__pyx_n_s_TSF;
-static PyObject *__pyx_n_s_TYPPRICE;
-static PyObject *__pyx_kp_s_This_is_a_pythonic_wrapper_arou;
-static PyObject *__pyx_kp_s_Too_many_price_arguments_expecte;
-static PyObject *__pyx_kp_s_Triangular_Moving_Average;
-static PyObject *__pyx_kp_s_Triple_Exponential_Moving_Averag;
-static PyObject *__pyx_kp_s_Triple_Generalized_Double_Expone;
-static PyObject *__pyx_n_s_TypeError;
-static PyObject *__pyx_n_s_ULTOSC;
-static PyObject *__pyx_kp_s_Unknown_Error;
-static PyObject *__pyx_kp_s_Unknown_Error_TA_UNKNOWN_ERR;
-static PyObject *__pyx_n_s_VAR;
-static PyObject *__pyx_n_s_ValueError;
-static PyObject *__pyx_kp_s_Values_represent_a_lower_limit;
-static PyObject *__pyx_kp_s_Values_represent_an_upper_limit;
-static PyObject *__pyx_n_s_WCLPRICE;
-static PyObject *__pyx_n_s_WILLR;
-static PyObject *__pyx_n_s_WMA;
-static PyObject *__pyx_kp_s_Weighted_Moving_Average;
-static PyObject *__pyx_kp_s__10;
-static PyObject *__pyx_kp_s__11;
-static PyObject *__pyx_kp_s__5;
-static PyObject *__pyx_kp_s__6;
-static PyObject *__pyx_kp_s__8;
-static PyObject *__pyx_kp_s__9;
-static PyObject *__pyx_n_s_acceleration;
-static PyObject *__pyx_n_s_accelerationinitlong;
-static PyObject *__pyx_n_s_accelerationinitshort;
-static PyObject *__pyx_n_s_accelerationlong;
-static PyObject *__pyx_n_s_accelerationmaxlong;
-static PyObject *__pyx_n_s_accelerationmaxshort;
-static PyObject *__pyx_n_s_accelerationshort;
-static PyObject *__pyx_kp_s_any_ndarray;
-static PyObject *__pyx_n_s_arg;
-static PyObject *__pyx_n_s_args;
-static PyObject *__pyx_n_s_ascii;
-static PyObject *__pyx_n_s_astype;
-static PyObject *__pyx_n_s_avgperiod;
-static PyObject *__pyx_n_s_b;
-static PyObject *__pyx_n_s_begidx;
-static PyObject *__pyx_n_s_bytes2str;
-static PyObject *__pyx_n_s_call;
-static PyObject *__pyx_n_s_call_function;
-static PyObject *__pyx_n_s_check_opt_input_value;
-static PyObject *__pyx_n_s_cline_in_traceback;
-static PyObject *__pyx_n_s_close;
-static PyObject *__pyx_n_s_close_data;
-static PyObject *__pyx_n_s_collections;
-static PyObject *__pyx_n_s_column_stack;
-static PyObject *__pyx_n_s_columns;
-static PyObject *__pyx_n_s_copy;
-static PyObject *__pyx_n_s_decode;
-static PyObject *__pyx_n_s_default_value;
-static PyObject *__pyx_n_s_defaults;
-static PyObject *__pyx_n_s_display_name;
-static PyObject *__pyx_kp_s_display_name_s_group_s;
-static PyObject *__pyx_n_s_doc;
-static PyObject *__pyx_n_s_docs;
-static PyObject *__pyx_n_s_documentation;
-static PyObject *__pyx_n_s_endidx;
-static PyObject *__pyx_n_s_enumerate;
-static PyObject *__pyx_n_s_factor;
-static PyObject *__pyx_n_s_fastd_matype;
-static PyObject *__pyx_n_s_fastd_period;
-static PyObject *__pyx_n_s_fastk_period;
-static PyObject *__pyx_n_s_fastlimit;
-static PyObject *__pyx_n_s_fastmatype;
-static PyObject *__pyx_n_s_fastperiod;
-static PyObject *__pyx_n_s_flag;
-static PyObject *__pyx_n_s_flags;
-static PyObject *__pyx_n_s_flags_lookup_dict;
-static PyObject *__pyx_n_s_func_args;
-static PyObject *__pyx_n_s_func_info;
-static PyObject *__pyx_n_s_func_line;
-static PyObject *__pyx_n_s_func_object;
-static PyObject *__pyx_n_s_function_flags;
-static PyObject *__pyx_n_s_function_name;
-static PyObject *__pyx_n_s_functions;
-static PyObject *__pyx_n_s_get_defaults_and_docs;
-static PyObject *__pyx_n_s_get_flags;
-static PyObject *__pyx_n_s_get_input_arrays;
-static PyObject *__pyx_n_s_get_input_names;
-static PyObject *__pyx_n_s_get_opt_input_value;
-static PyObject *__pyx_n_s_get_parameters;
-static PyObject *__pyx_n_s_getitem;
-static PyObject *__pyx_n_s_group;
-static PyObject *__pyx_n_s_groups;
-static PyObject *__pyx_n_s_help;
-static PyObject *__pyx_n_s_high;
-static PyObject *__pyx_n_s_high_data;
-static PyObject *__pyx_n_s_holder;
-static PyObject *__pyx_n_s_i;
-static PyObject *__pyx_n_s_id;
-static PyObject *__pyx_n_s_idx;
-static PyObject *__pyx_n_s_import;
-static PyObject *__pyx_n_s_in;
-static PyObject *__pyx_n_s_index;
-static PyObject *__pyx_n_s_info;
-static PyObject *__pyx_n_s_init;
-static PyObject *__pyx_n_s_initialize_function_info;
-static PyObject *__pyx_kp_s_input_array_has_wrong_dimensions;
-static PyObject *__pyx_kp_s_input_array_lengths_are_differen;
-static PyObject *__pyx_kp_s_input_array_type_is_not_double;
-static PyObject *__pyx_n_s_input_arrays;
-static PyObject *__pyx_kp_s_input_arrays_2;
-static PyObject *__pyx_kp_s_input_arrays_parameter_missing_r;
-static PyObject *__pyx_n_s_input_name;
-static PyObject *__pyx_n_s_input_names;
-static PyObject *__pyx_n_s_input_price_series_names;
-static PyObject *__pyx_n_s_input_price_series_names_2;
-static PyObject *__pyx_kp_s_inputs_are_all_NaN;
-static PyObject *__pyx_n_s_integer;
-static PyObject *__pyx_kp_s_integer_values_are_100_0_or_100;
-static PyObject *__pyx_n_s_items;
-static PyObject *__pyx_n_s_join;
-static PyObject *__pyx_n_s_key;
-static PyObject *__pyx_n_s_keys;
-static PyObject *__pyx_n_s_kwargs;
-static PyObject *__pyx_n_s_length;
-static PyObject *__pyx_n_s_log;
-static PyObject *__pyx_n_s_lookback;
-static PyObject *__pyx_n_s_lookup;
-static PyObject *__pyx_n_s_low;
-static PyObject *__pyx_n_s_low_data;
-static PyObject *__pyx_n_s_lower;
-static PyObject *__pyx_n_s_main;
-static PyObject *__pyx_n_s_math;
-static PyObject *__pyx_n_s_matype;
-static PyObject *__pyx_n_s_max;
-static PyObject *__pyx_n_s_max_int;
-static PyObject *__pyx_n_s_maximum;
-static PyObject *__pyx_n_s_maxperiod;
-static PyObject *__pyx_n_s_metaclass;
-static PyObject *__pyx_n_s_min;
-static PyObject *__pyx_n_s_min_int;
-static PyObject *__pyx_n_s_minperiod;
-static PyObject *__pyx_n_s_missing_keys;
-static PyObject *__pyx_n_s_module;
-static PyObject *__pyx_n_s_msg;
-static PyObject *__pyx_n_s_name;
-static PyObject *__pyx_n_s_name_2;
-static PyObject *__pyx_n_s_nan;
-static PyObject *__pyx_n_s_nbdev;
-static PyObject *__pyx_n_s_nbdevdn;
-static PyObject *__pyx_n_s_nbdevup;
-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_num_inputs;
-static PyObject *__pyx_n_s_num_opt_inputs;
-static PyObject *__pyx_n_s_num_outputs;
-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_object;
-static PyObject *__pyx_n_s_offsetonreverse;
-static PyObject *__pyx_n_s_open;
-static PyObject *__pyx_n_s_openInterest;
-static PyObject *__pyx_n_s_open_data;
-static PyObject *__pyx_n_s_optIn;
-static PyObject *__pyx_n_s_opt_input;
-static PyObject *__pyx_n_s_opt_input_values;
-static PyObject *__pyx_n_s_ordereddict;
-static PyObject *__pyx_n_s_out;
-static PyObject *__pyx_n_s_outaroondown;
-static PyObject *__pyx_n_s_outaroonup;
-static PyObject *__pyx_n_s_outbegidx;
-static PyObject *__pyx_n_s_outfama;
-static PyObject *__pyx_n_s_outfastd;
-static PyObject *__pyx_n_s_outfastk;
-static PyObject *__pyx_n_s_outinphase;
-static PyObject *__pyx_n_s_outinteger;
-static PyObject *__pyx_n_s_outleadsine;
-static PyObject *__pyx_n_s_outmacd;
-static PyObject *__pyx_n_s_outmacdhist;
-static PyObject *__pyx_n_s_outmacdsignal;
-static PyObject *__pyx_n_s_outmama;
-static PyObject *__pyx_n_s_outmax;
-static PyObject *__pyx_n_s_outmaxidx;
-static PyObject *__pyx_n_s_outmin;
-static PyObject *__pyx_n_s_outminidx;
-static PyObject *__pyx_n_s_outnbelement;
-static PyObject *__pyx_n_s_output;
-static PyObject *__pyx_n_s_output_flags;
-static PyObject *__pyx_n_s_output_name;
-static PyObject *__pyx_n_s_output_names;
-static PyObject *__pyx_n_s_outputs;
-static PyObject *__pyx_n_s_outquadrature;
-static PyObject *__pyx_n_s_outreal;
-static PyObject *__pyx_n_s_outreallowerband;
-static PyObject *__pyx_n_s_outrealmiddleband;
-static PyObject *__pyx_n_s_outrealupperband;
-static PyObject *__pyx_n_s_outsine;
-static PyObject *__pyx_n_s_outslowd;
-static PyObject *__pyx_n_s_outslowk;
-static PyObject *__pyx_n_s_pandas;
-static PyObject *__pyx_n_s_param;
-static PyObject *__pyx_n_s_param_name;
-static PyObject *__pyx_n_s_parameters;
-static PyObject *__pyx_n_s_params;
-static PyObject *__pyx_n_s_penetration;
-static PyObject *__pyx_n_s_period;
-static PyObject *__pyx_n_s_periods;
-static PyObject *__pyx_n_s_periods_data;
-static PyObject *__pyx_n_s_pop;
-static PyObject *__pyx_n_s_prepare;
-static PyObject *__pyx_n_s_price;
-static PyObject *__pyx_n_s_price0;
-static PyObject *__pyx_n_s_price1;
-static PyObject *__pyx_n_s_price_series;
-static PyObject *__pyx_n_s_prices;
-static PyObject *__pyx_n_s_property;
-static PyObject *__pyx_n_s_qualname;
-static PyObject *__pyx_n_s_range;
-static PyObject *__pyx_n_s_rangetype;
-static PyObject *__pyx_n_s_real;
-static PyObject *__pyx_n_s_real0;
-static PyObject *__pyx_n_s_real0_data;
-static PyObject *__pyx_n_s_real1;
-static PyObject *__pyx_n_s_real1_data;
-static PyObject *__pyx_n_s_real_data;
-static PyObject *__pyx_n_s_replace;
-static PyObject *__pyx_n_s_repr;
-static PyObject *__pyx_n_s_results;
-static PyObject *__pyx_n_s_ret;
-static PyObject *__pyx_n_s_retCode;
-static PyObject *__pyx_n_s_ret_code;
-static PyObject *__pyx_n_s_run;
-static PyObject *__pyx_n_s_s;
-static PyObject *__pyx_kp_s_s_2;
-static PyObject *__pyx_kp_s_s_3;
-static PyObject *__pyx_kp_s_s_4;
-static PyObject *__pyx_kp_s_s_function_failed_with_error_co;
-static PyObject *__pyx_kp_s_s_s;
-static PyObject *__pyx_kp_s_s_s_2;
-static PyObject *__pyx_n_s_self;
-static PyObject *__pyx_n_s_series;
-static PyObject *__pyx_n_s_set_function_args;
-static PyObject *__pyx_n_s_set_input_arrays;
-static PyObject *__pyx_n_s_set_input_names;
-static PyObject *__pyx_n_s_set_parameters;
-static PyObject *__pyx_n_s_settingtype;
-static PyObject *__pyx_n_s_signalmatype;
-static PyObject *__pyx_n_s_signalperiod;
-static PyObject *__pyx_n_s_skip_first;
-static PyObject *__pyx_n_s_slowd_matype;
-static PyObject *__pyx_n_s_slowd_period;
-static PyObject *__pyx_n_s_slowk_matype;
-static PyObject *__pyx_n_s_slowk_period;
-static PyObject *__pyx_n_s_slowlimit;
-static PyObject *__pyx_n_s_slowmatype;
-static PyObject *__pyx_n_s_slowperiod;
-static PyObject *__pyx_n_s_startvalue;
-static PyObject *__pyx_n_s_str;
-static PyObject *__pyx_n_s_str2bytes;
-static PyObject *__pyx_n_s_stream_ACOS;
-static PyObject *__pyx_n_s_stream_AD;
-static PyObject *__pyx_n_s_stream_ADD;
-static PyObject *__pyx_n_s_stream_ADOSC;
-static PyObject *__pyx_n_s_stream_ADX;
-static PyObject *__pyx_n_s_stream_ADXR;
-static PyObject *__pyx_n_s_stream_APO;
-static PyObject *__pyx_n_s_stream_AROON;
-static PyObject *__pyx_n_s_stream_AROONOSC;
-static PyObject *__pyx_n_s_stream_ASIN;
-static PyObject *__pyx_n_s_stream_ATAN;
-static PyObject *__pyx_n_s_stream_ATR;
-static PyObject *__pyx_n_s_stream_AVGPRICE;
-static PyObject *__pyx_n_s_stream_BBANDS;
-static PyObject *__pyx_n_s_stream_BETA;
-static PyObject *__pyx_n_s_stream_BOP;
-static PyObject *__pyx_n_s_stream_CCI;
-static PyObject *__pyx_n_s_stream_CDL2CROWS;
-static PyObject *__pyx_n_s_stream_CDL3BLACKCROWS;
-static PyObject *__pyx_n_s_stream_CDL3INSIDE;
-static PyObject *__pyx_n_s_stream_CDL3LINESTRIKE;
-static PyObject *__pyx_n_s_stream_CDL3OUTSIDE;
-static PyObject *__pyx_n_s_stream_CDL3STARSINSOUTH;
-static PyObject *__pyx_n_s_stream_CDL3WHITESOLDIERS;
-static PyObject *__pyx_n_s_stream_CDLABANDONEDBABY;
-static PyObject *__pyx_n_s_stream_CDLADVANCEBLOCK;
-static PyObject *__pyx_n_s_stream_CDLBELTHOLD;
-static PyObject *__pyx_n_s_stream_CDLBREAKAWAY;
-static PyObject *__pyx_n_s_stream_CDLCLOSINGMARUBOZU;
-static PyObject *__pyx_n_s_stream_CDLCONCEALBABYSWALL;
-static PyObject *__pyx_n_s_stream_CDLCOUNTERATTACK;
-static PyObject *__pyx_n_s_stream_CDLDARKCLOUDCOVER;
-static PyObject *__pyx_n_s_stream_CDLDOJI;
-static PyObject *__pyx_n_s_stream_CDLDOJISTAR;
-static PyObject *__pyx_n_s_stream_CDLDRAGONFLYDOJI;
-static PyObject *__pyx_n_s_stream_CDLENGULFING;
-static PyObject *__pyx_n_s_stream_CDLEVENINGDOJISTAR;
-static PyObject *__pyx_n_s_stream_CDLEVENINGSTAR;
-static PyObject *__pyx_n_s_stream_CDLGAPSIDESIDEWHITE;
-static PyObject *__pyx_n_s_stream_CDLGRAVESTONEDOJI;
-static PyObject *__pyx_n_s_stream_CDLHAMMER;
-static PyObject *__pyx_n_s_stream_CDLHANGINGMAN;
-static PyObject *__pyx_n_s_stream_CDLHARAMI;
-static PyObject *__pyx_n_s_stream_CDLHARAMICROSS;
-static PyObject *__pyx_n_s_stream_CDLHIGHWAVE;
-static PyObject *__pyx_n_s_stream_CDLHIKKAKE;
-static PyObject *__pyx_n_s_stream_CDLHIKKAKEMOD;
-static PyObject *__pyx_n_s_stream_CDLHOMINGPIGEON;
-static PyObject *__pyx_n_s_stream_CDLIDENTICAL3CROWS;
-static PyObject *__pyx_n_s_stream_CDLINNECK;
-static PyObject *__pyx_n_s_stream_CDLINVERTEDHAMMER;
-static PyObject *__pyx_n_s_stream_CDLKICKING;
-static PyObject *__pyx_n_s_stream_CDLKICKINGBYLENGTH;
-static PyObject *__pyx_n_s_stream_CDLLADDERBOTTOM;
-static PyObject *__pyx_n_s_stream_CDLLONGLEGGEDDOJI;
-static PyObject *__pyx_n_s_stream_CDLLONGLINE;
-static PyObject *__pyx_n_s_stream_CDLMARUBOZU;
-static PyObject *__pyx_n_s_stream_CDLMATCHINGLOW;
-static PyObject *__pyx_n_s_stream_CDLMATHOLD;
-static PyObject *__pyx_n_s_stream_CDLMORNINGDOJISTAR;
-static PyObject *__pyx_n_s_stream_CDLMORNINGSTAR;
-static PyObject *__pyx_n_s_stream_CDLONNECK;
-static PyObject *__pyx_n_s_stream_CDLPIERCING;
-static PyObject *__pyx_n_s_stream_CDLRICKSHAWMAN;
-static PyObject *__pyx_n_s_stream_CDLRISEFALL3METHODS;
-static PyObject *__pyx_n_s_stream_CDLSEPARATINGLINES;
-static PyObject *__pyx_n_s_stream_CDLSHOOTINGSTAR;
-static PyObject *__pyx_n_s_stream_CDLSHORTLINE;
-static PyObject *__pyx_n_s_stream_CDLSPINNINGTOP;
-static PyObject *__pyx_n_s_stream_CDLSTALLEDPATTERN;
-static PyObject *__pyx_n_s_stream_CDLSTICKSANDWICH;
-static PyObject *__pyx_n_s_stream_CDLTAKURI;
-static PyObject *__pyx_n_s_stream_CDLTASUKIGAP;
-static PyObject *__pyx_n_s_stream_CDLTHRUSTING;
-static PyObject *__pyx_n_s_stream_CDLTRISTAR;
-static PyObject *__pyx_n_s_stream_CDLUNIQUE3RIVER;
-static PyObject *__pyx_n_s_stream_CDLUPSIDEGAP2CROWS;
-static PyObject *__pyx_n_s_stream_CDLXSIDEGAP3METHODS;
-static PyObject *__pyx_n_s_stream_CEIL;
-static PyObject *__pyx_n_s_stream_CMO;
-static PyObject *__pyx_n_s_stream_CORREL;
-static PyObject *__pyx_n_s_stream_COS;
-static PyObject *__pyx_n_s_stream_COSH;
-static PyObject *__pyx_n_s_stream_DEMA;
-static PyObject *__pyx_n_s_stream_DIV;
-static PyObject *__pyx_n_s_stream_DX;
-static PyObject *__pyx_n_s_stream_EMA;
-static PyObject *__pyx_n_s_stream_EXP;
-static PyObject *__pyx_n_s_stream_FLOOR;
-static PyObject *__pyx_n_s_stream_HT_DCPERIOD;
-static PyObject *__pyx_n_s_stream_HT_DCPHASE;
-static PyObject *__pyx_n_s_stream_HT_PHASOR;
-static PyObject *__pyx_n_s_stream_HT_SINE;
-static PyObject *__pyx_n_s_stream_HT_TRENDLINE;
-static PyObject *__pyx_n_s_stream_HT_TRENDMODE;
-static PyObject *__pyx_n_s_stream_KAMA;
-static PyObject *__pyx_n_s_stream_LINEARREG;
-static PyObject *__pyx_n_s_stream_LINEARREG_ANGLE;
-static PyObject *__pyx_n_s_stream_LINEARREG_INTERCEPT;
-static PyObject *__pyx_n_s_stream_LINEARREG_SLOPE;
-static PyObject *__pyx_n_s_stream_LN;
-static PyObject *__pyx_n_s_stream_LOG10;
-static PyObject *__pyx_n_s_stream_MA;
-static PyObject *__pyx_n_s_stream_MACD;
-static PyObject *__pyx_n_s_stream_MACDEXT;
-static PyObject *__pyx_n_s_stream_MACDFIX;
-static PyObject *__pyx_n_s_stream_MAMA;
-static PyObject *__pyx_n_s_stream_MAVP;
-static PyObject *__pyx_n_s_stream_MAX;
-static PyObject *__pyx_n_s_stream_MAXINDEX;
-static PyObject *__pyx_n_s_stream_MEDPRICE;
-static PyObject *__pyx_n_s_stream_MFI;
-static PyObject *__pyx_n_s_stream_MIDPOINT;
-static PyObject *__pyx_n_s_stream_MIDPRICE;
-static PyObject *__pyx_n_s_stream_MIN;
-static PyObject *__pyx_n_s_stream_MININDEX;
-static PyObject *__pyx_n_s_stream_MINMAX;
-static PyObject *__pyx_n_s_stream_MINMAXINDEX;
-static PyObject *__pyx_n_s_stream_MINUS_DI;
-static PyObject *__pyx_n_s_stream_MINUS_DM;
-static PyObject *__pyx_n_s_stream_MOM;
-static PyObject *__pyx_n_s_stream_MULT;
-static PyObject *__pyx_n_s_stream_NATR;
-static PyObject *__pyx_n_s_stream_OBV;
-static PyObject *__pyx_n_s_stream_PLUS_DI;
-static PyObject *__pyx_n_s_stream_PLUS_DM;
-static PyObject *__pyx_n_s_stream_PPO;
-static PyObject *__pyx_n_s_stream_ROC;
-static PyObject *__pyx_n_s_stream_ROCP;
-static PyObject *__pyx_n_s_stream_ROCR;
-static PyObject *__pyx_n_s_stream_ROCR100;
-static PyObject *__pyx_n_s_stream_RSI;
-static PyObject *__pyx_n_s_stream_SAR;
-static PyObject *__pyx_n_s_stream_SAREXT;
-static PyObject *__pyx_n_s_stream_SIN;
-static PyObject *__pyx_n_s_stream_SINH;
-static PyObject *__pyx_n_s_stream_SMA;
-static PyObject *__pyx_n_s_stream_SQRT;
-static PyObject *__pyx_n_s_stream_STDDEV;
-static PyObject *__pyx_n_s_stream_STOCH;
-static PyObject *__pyx_n_s_stream_STOCHF;
-static PyObject *__pyx_n_s_stream_STOCHRSI;
-static PyObject *__pyx_n_s_stream_SUB;
-static PyObject *__pyx_n_s_stream_SUM;
-static PyObject *__pyx_n_s_stream_T3;
-static PyObject *__pyx_n_s_stream_TAN;
-static PyObject *__pyx_n_s_stream_TANH;
-static PyObject *__pyx_n_s_stream_TEMA;
-static PyObject *__pyx_n_s_stream_TRANGE;
-static PyObject *__pyx_n_s_stream_TRIMA;
-static PyObject *__pyx_n_s_stream_TRIX;
-static PyObject *__pyx_n_s_stream_TSF;
-static PyObject *__pyx_n_s_stream_TYPPRICE;
-static PyObject *__pyx_n_s_stream_ULTOSC;
-static PyObject *__pyx_n_s_stream_VAR;
-static PyObject *__pyx_n_s_stream_WCLPRICE;
-static PyObject *__pyx_n_s_stream_WILLR;
-static PyObject *__pyx_n_s_stream_WMA;
-static PyObject *__pyx_n_s_sys;
-static PyObject *__pyx_n_s_ta_func_unst_ids;
-static PyObject *__pyx_n_s_ta_getFuncInfo;
-static PyObject *__pyx_n_s_ta_getFuncTable;
-static PyObject *__pyx_n_s_ta_getGroupTable;
-static PyObject *__pyx_n_s_ta_getInputParameterInfo;
-static PyObject *__pyx_n_s_ta_getOptInputParameterInfo;
-static PyObject *__pyx_n_s_ta_getOutputParameterInfo;
-static PyObject *__pyx_n_s_ta_get_compatibility;
-static PyObject *__pyx_n_s_ta_get_unstable_period;
-static PyObject *__pyx_n_s_ta_initialize;
-static PyObject *__pyx_n_s_ta_restore_candle_default_setti;
-static PyObject *__pyx_n_s_ta_set_candle_settings;
-static PyObject *__pyx_n_s_ta_set_compatibility;
-static PyObject *__pyx_n_s_ta_set_unstable_period;
-static PyObject *__pyx_n_s_ta_shutdown;
-static PyObject *__pyx_n_s_ta_version;
-static PyObject *__pyx_n_s_table;
-static PyObject *__pyx_kp_s_talib__abstract_pxi;
-static PyObject *__pyx_kp_s_talib__common_pxi;
-static PyObject *__pyx_kp_s_talib__func_pxi;
-static PyObject *__pyx_kp_s_talib__stream_pxi;
-static PyObject *__pyx_n_s_talib__ta_lib;
-static PyObject *__pyx_n_s_test;
-static PyObject *__pyx_n_s_timeStamp;
-static PyObject *__pyx_n_s_timeperiod;
-static PyObject *__pyx_n_s_timeperiod1;
-static PyObject *__pyx_n_s_timeperiod2;
-static PyObject *__pyx_n_s_timeperiod3;
-static PyObject *__pyx_n_s_type;
-static PyObject *__pyx_n_s_type_2;
-static PyObject *__pyx_n_s_unicode;
-static PyObject *__pyx_kp_u_unknown_dtype_code_in_numpy_pxd;
-static PyObject *__pyx_n_s_update;
-static PyObject *__pyx_n_s_update_info;
-static PyObject *__pyx_n_s_upper;
-static PyObject *__pyx_n_s_value;
-static PyObject *__pyx_n_s_value_range;
-static PyObject *__pyx_n_s_values;
-static PyObject *__pyx_n_s_version;
-static PyObject *__pyx_n_s_vfactor;
-static PyObject *__pyx_n_s_volume;
-static PyObject *__pyx_n_s_volume_data;
-static PyObject *__pyx_n_s_xrange;
+static const char __pyx_k_input_arrays_parameter_missing_r[] = "input_arrays parameter missing required data key";
+static const char __pyx_k_numpy__core_multiarray_failed_to[] = "numpy._core.multiarray failed to import";
+static const char __pyx_k_numpy__core_umath_failed_to_impo[] = "numpy._core.umath failed to import";
+static const char __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_BfHB_2[] = "\200\001\360,\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\013\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\n\210+\220Q\220a\330\004\017\210y\230\003\2301\330\004\014\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\r\210]\230!\2306\240\026\240u\250A\330\004\021\220\021\330\004\021\220\033\230B\230f\240H\250B\250d\260&\270\010\300\002\300$\300l\320R^\320^i\320iv\320vw\360\000\000x\001D\002\360\000\000D\002E\002\360\000\000E\002T\002\360\000\000T\002U\002\360\000\000U\002V\002\330\004\025\220Q\220n\240A\330\004\013\2101";
+static const char __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_b_hb_2[] = "\200\001\360,\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\013\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\n\210+\220Q\220a\330\004\017\210y\230\003\2301\330\004\014\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\r\210]\230!\2306\240\026\240u\250A\330\004\021\220\021\330\004\021\320\021&\240b\250\006\250h\260b\270\004\270F\300(\310\"\310D\320P\\\320\\h\320hs\360\000\000t\001A\002\360\000\000A\002B\002\360\000\000B\002N\002\360\000\000N\002O\002\360\000\000O\002^\002\360\000\000^\002_\002\360\000\000_\002`\002\330\004\025\220Q\320\026.\250a\330\004\013\2101";
+static const char __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_fHBd_2[] = "\200\001\360,\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\013\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\n\210+\220Q\220a\330\004\017\210y\230\003\2301\330\004\014\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\r\210]\230!\2306\240\026\240u\250A\330\004\021\220\021\330\004\021\320\021(\250\002\250&\260\010\270\002\270$\270f\300H\310B\310d\320R^\320^j\320ju\360\000\000v\001C\002\360\000\000C\002D\002\360\000\000D\002P\002\360\000\000P\002Q\002\360\000\000Q\002`\002\360\000\000`\002a\002\360\000\000a\002b\002\330\004\025\220Q\320\0260\260\001\330\004\013\2101";
+static const char __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_r_xr_2[] = "\200\001\360,\000\005\014\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\013\210;\220a\220q\330\004\020\220\t\230\024\230Q\330\004\n\210+\220Q\220a\330\004\017\210y\230\003\2301\330\004\014\210K\220q\230\001\330\004\021\220\031\230%\230q\330\004\r\210]\230!\2306\240\026\240u\250A\330\004\021\220\021\330\004\021\320\021'\240r\250\026\250x\260r\270\024\270V\3008\3102\310T\320Q]\320]i\320it\360\000\000u\001B\002\360\000\000B\002C\002\360\000\000C\002O\002\360\000\000O\002P\002\360\000\000P\002_\002\360\000\000_\002`\002\360\000\000`\002a\002\330\004\025\220Q\320\026/\250q\330\004\013\2101";
+static const char __pyx_k_aq_T_q_8_T_U_7_A_we_4A_q_4y_4vQ_2[] = "\200\001\360&\000\005\014\210;\220a\220q\330\004\r\210T\220\026\220q\230\001\330\004\r\210]\230!\2308\240:\250T\260\021\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\0334\260A\330\004\021\220\036\230q\240\010\250\001\330\004\021\320\021!\240\022\2404\240y\260\013\2704\270v\300Q\300i\310q\320P\\\320\\]\320]l\320lt\320t~\360\000\000\177\001E\002\360\000\000E\002F\002\360\000\000F\002G\002\330\004\025\220Q\320\026)\250\021\330\004\013\2101";
+static const char __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_2[] = "\200\001\360&\000\005\014\210;\220a\220q\330\004\013\210;\220a\220q\330\004\n\210+\220Q\220a\330\004\014\210K\220q\230\001\330\004\r\210]\230!\2306\240\026\240u\250A\330\004\r\210]\230!\2308\240:\250T\260\030\270\032\3004\300x\310z\320Y\\\320\\d\320dn\320ns\320st\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033+\2501\330\004\016\320\016\037\230q\240\010\250\001\330\004\021\220\027\230\002\230$\230i\240{\260$\260f\270A\270Y\300k\320QU\320U[\320[\\\320\\e\320ep\320ps\320sy\320yz\360\000\000{\001D\002\360\000\000D\002O\002\360\000\000O\002T\002\360\000\000T\002Z\002\360\000\000Z\002[\002\360\000\000[\002d\002\360\000\000d\002e\002\360\000\000e\002q\002\360\000\000q\002r\002\360\000\000r\002A\003\360\000\000A\003L\003\360\000\000L\003S\003\360\000\000S\003Y\003\360\000\000Y\003Z\003\360\000\000Z\003[\003\330\004\025\220Q\220j\240\001\330\004\013\2101";
+static const char __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_3[] = "\200\001\360&\000\005\014\210;\220a\220q\330\004\013\210;\220a\220q\330\004\n\210+\220Q\220a\330\004\014\210K\220q\230\001\330\004\r\210]\230!\2306\240\026\240u\250A\330\004\r\210]\230!\2308\240:\250T\260\030\270\032\3004\300x\310z\320Y\\\320\\d\320dn\320ns\320st\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\0331\260\021\330\004\021\220\036\230q\240\010\250\001\330\004\021\220\035\230b\240\004\240I\250[\270\004\270F\300!\3009\310K\320W[\320[a\320ab\320bk\320kv\320vy\320y\177\360\000\000@\002A\002\360\000\000A\002J\002\360\000\000J\002U\002\360\000\000U\002Z\002\360\000\000Z\002`\002\360\000\000`\002a\002\360\000\000a\002j\002\360\000\000j\002k\002\360\000\000k\002w\002\360\000\000w\002x\002\360\000\000x\002G\003\360\000\000G\003O\003\360\000\000O\003Y\003\360\000\000Y\003_\003\360\000\000_\003`\003\360\000\000`\003a\003\330\004\025\220Q\320\026&\240a\330\004\013\2101";
+static const char __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_4[] = "\200\001\360&\000\005\014\210;\220a\220q\330\004\013\210;\220a\220q\330\004\n\210+\220Q\220a\330\004\014\210K\220q\230\001\330\004\r\210]\230!\2306\240\026\240u\250A\330\004\r\210]\230!\2308\240:\250T\260\030\270\032\3004\300x\310z\320Y\\\320\\d\320dn\320ns\320st\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\0336\260a\330\004\021\220\036\230q\240\010\250\001\330\004\021\320\021#\2402\240T\250\031\260+\270T\300\026\300q\310\t\320Q\\\320\\`\320`f\320fg\320gp\320p{\320{~\360\000\000\177\001E\002\360\000\000E\002F\002\360\000\000F\002O\002\360\000\000O\002Z\002\360\000\000Z\002_\002\360\000\000_\002e\002\360\000\000e\002f\002\360\000\000f\002o\002\360\000\000o\002p\002\360\000\000p\002|\002\360\000\000|\002}\002\360\000\000}\002L\003\360\000\000L\003T\003\360\000\000T\003^\003\360\000\000^\003d\003\360\000\000d\003e\003\360\000\000e\003f\003\330\004\025\220Q\320\026+\2501\330\004\013\2101";
+static const char __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_5[] = "\200\001\360&\000\005\014\210;\220a\220q\330\004\013\210;\220a\220q\330\004\n\210+\220Q\220a\330\004\014\210K\220q\230\001\330\004\r\210]\230!\2306\240\026\240u\250A\330\004\r\210]\230!\2308\240:\250T\260\030\270\032\3004\300x\310z\320Y\\\320\\d\320dn\320ns\320st\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\0332\260!\330\004\021\220\036\230q\240\010\250\001\330\004\021\220\036\230r\240\024\240Y\250k\270\024\270V\3001\300I\310[\320X\\\320\\b\320bc\320cl\320lw\320wz\360\000\000{\001A\002\360\000\000A\002B\002\360\000\000B\002K\002\360\000\000K\002V\002\360\000\000V\002[\002\360\000\000[\002a\002\360\000\000a\002b\002\360\000\000b\002k\002\360\000\000k\002l\002\360\000\000l\002x\002\360\000\000x\002y\002\360\000\000y\002H\003\360\000\000H\003P\003\360\000\000P\003Z\003\360\000\000Z\003`\003\360\000\000`\003a\003\360\000\000a\003b\003\330\004\025\220Q\320\026'\240q\330\004\013\2101";
+static const char __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_6[] = "\200\001\360&\000\005\014\210;\220a\220q\330\004\013\210;\220a\220q\330\004\n\210+\220Q\220a\330\004\014\210K\220q\230\001\330\004\r\210]\230!\2306\240\026\240u\250A\330\004\r\210]\230!\2308\240:\250T\260\030\270\032\3004\300x\310z\320Y\\\320\\d\320dn\320ns\320st\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\0333\2601\330\004\021\220\036\230q\240\010\250\001\330\004\021\220\037\240\002\240$\240i\250{\270$\270f\300A\300Y\310k\320Y]\320]c\320cd\320dm\320mx\320x{\360\000\000|\001B\002\360\000\000B\002C\002\360\000\000C\002L\002\360\000\000L\002W\002\360\000\000W\002\\\002\360\000\000\\\002b\002\360\000\000b\002c\002\360\000\000c\002l\002\360\000\000l\002m\002\360\000\000m\002y\002\360\000\000y\002z\002\360\000\000z\002I\003\360\000\000I\003Q\003\360\000\000Q\003[\003\360\000\000[\003a\003\360\000\000a\003b\003\360\000\000b\003c\003\330\004\025\220Q\320\026(\250\001\330\004\013\2101";
+static const char __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_7[] = "\200\001\360&\000\005\014\210;\220a\220q\330\004\013\210;\220a\220q\330\004\n\210+\220Q\220a\330\004\014\210K\220q\230\001\330\004\r\210]\230!\2306\240\026\240u\250A\330\004\r\210]\230!\2308\240:\250T\260\030\270\032\3004\300x\310z\320Y\\\320\\d\320dn\320ns\320st\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\0338\270\001\330\004\021\220\036\230q\240\010\250\001\330\004\021\320\021%\240R\240t\2509\260K\270t\3006\310\021\310)\320S^\320^b\320bh\320hi\320ir\320r}\360\000\000~\001A\002\360\000\000A\002G\002\360\000\000G\002H\002\360\000\000H\002Q\002\360\000\000Q\002\\\002\360\000\000\\\002a\002\360\000\000a\002g\002\360\000\000g\002h\002\360\000\000h\002q\002\360\000\000q\002r\002\360\000\000r\002~\002\360\000\000~\002\177\002\360\000\000\177\002N\003\360\000\000N\003V\003\360\000\000V\003`\003\360\000\000`\003f\003\360\000\000f\003g\003\360\000\000g\003h\003\330\004\025\220Q\320\026-\250Q\330\004\013\2101";
+static const char __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_8[] = "\200\001\360&\000\005\014\210;\220a\220q\330\004\013\210;\220a\220q\330\004\n\210+\220Q\220a\330\004\014\210K\220q\230\001\330\004\r\210]\230!\2306\240\026\240u\250A\330\004\r\210]\230!\2308\240:\250T\260\030\270\032\3004\300x\310z\320Y\\\320\\d\320dn\320ns\320st\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\0339\270\021\330\004\021\220\036\230q\240\010\250\001\330\004\021\320\021&\240b\250\004\250I\260[\300\004\300F\310!\3109\320T_\320_c\320ci\320ij\320js\320s~\360\000\000\177\001B\002\360\000\000B\002H\002\360\000\000H\002I\002\360\000\000I\002R\002\360\000\000R\002]\002\360\000\000]\002b\002\360\000\000b\002h\002\360\000\000h\002i\002\360\000\000i\002r\002\360\000\000r\002s\002\360\000\000s\002\177\002\360\000\000\177\002@\003\360\000\000@\003O\003\360\000\000O\003W\003\360\000\000W\003a\003\360\000\000a\003g\003\360\000\000g\003h\003\360\000\000h\003i\003\330\004\025\220Q\320\026.\250a\330\004\013\2101";
+static const char __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_9[] = "\200\001\360&\000\005\014\210;\220a\220q\330\004\013\210;\220a\220q\330\004\n\210+\220Q\220a\330\004\014\210K\220q\230\001\330\004\r\210]\230!\2306\240\026\240u\250A\330\004\r\210]\230!\2308\240:\250T\260\030\270\032\3004\300x\310z\320Y\\\320\\d\320dn\320ns\320st\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\0337\260q\330\004\021\220\036\230q\240\010\250\001\330\004\021\320\021$\240B\240d\250)\260;\270d\300&\310\001\310\031\320R]\320]a\320ag\320gh\320hq\320q|\320|\177\360\000\000@\002F\002\360\000\000F\002G\002\360\000\000G\002P\002\360\000\000P\002[\002\360\000\000[\002`\002\360\000\000`\002f\002\360\000\000f\002g\002\360\000\000g\002p\002\360\000\000p\002q\002\360\000\000q\002}\002\360\000\000}\002~\002\360\000\000~\002M\003\360\000\000M\003U\003\360\000\000U\003_\003\360\000\000_\003e\003\360\000\000e\003f\003\360\000\000f\003g\003\330\004\025\220Q\320\026,\250A\330\004\013\2101";
+static const char __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_10[] = "\200\001\360&\000\005\014\210;\220a\220q\330\004\013\210;\220a\220q\330\004\n\210+\220Q\220a\330\004\014\210K\220q\230\001\330\004\r\210]\230!\2306\240\026\240u\250A\330\004\r\210]\230!\2308\240:\250T\260\030\270\032\3004\300x\310z\320Y\\\320\\d\320dn\320ns\320st\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\0334\260A\330\004\021\220\036\230q\240\010\250\001\330\004\021\320\021!\240\022\2404\240y\260\013\2704\270v\300Q\300i\310{\320Z^\320^d\320de\320en\320ny\320y|\360\000\000}\001C\002\360\000\000C\002D\002\360\000\000D\002M\002\360\000\000M\002X\002\360\000\000X\002]\002\360\000\000]\002c\002\360\000\000c\002d\002\360\000\000d\002m\002\360\000\000m\002n\002\360\000\000n\002z\002\360\000\000z\002{\002\360\000\000{\002J\003\360\000\000J\003R\003\360\000\000R\003\\\003\360\000\000\\\003b\003\360\000\000b\003c\003\360\000\000c\003d\003\330\004\025\220Q\320\026)\250\021\330\004\013\2101";
+static const char __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_11[] = "\200\001\360&\000\005\014\210;\220a\220q\330\004\013\210;\220a\220q\330\004\n\210+\220Q\220a\330\004\014\210K\220q\230\001\330\004\r\210]\230!\2306\240\026\240u\250A\330\004\r\210]\230!\2308\240:\250T\260\030\270\032\3004\300x\310z\320Y\\\320\\d\320dn\320ns\320st\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033:\270!\330\004\021\220\036\230q\240\010\250\001\330\004\021\320\021'\240r\250\024\250Y\260k\300\024\300V\3101\310I\320U`\320`d\320dj\320jk\320kt\320t\177\360\000\000@\002C\002\360\000\000C\002I\002\360\000\000I\002J\002\360\000\000J\002S\002\360\000\000S\002^\002\360\000\000^\002c\002\360\000\000c\002i\002\360\000\000i\002j\002\360\000\000j\002s\002\360\000\000s\002t\002\360\000\000t\002@\003\360\000\000@\003A\003\360\000\000A\003P\003\360\000\000P\003X\003\360\000\000X\003b\003\360\000\000b\003h\003\360\000\000h\003i\003\360\000\000i\003j\003\330\004\025\220Q\320\026/\250q\330\004\013\2101";
+static const char __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_12[] = "\200\001\360&\000\005\014\210;\220a\220q\330\004\013\210;\220a\220q\330\004\n\210+\220Q\220a\330\004\014\210K\220q\230\001\330\004\r\210]\230!\2306\240\026\240u\250A\330\004\r\210]\230!\2308\240:\250T\260\030\270\032\3004\300x\310z\320Y\\\320\\d\320dn\320ns\320st\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033;\2701\330\004\021\220\036\230q\240\010\250\001\330\004\021\320\021(\250\002\250$\250i\260{\300$\300f\310A\310Y\320Va\320ae\320ek\320kl\320lu\360\000\000v\001A\002\360\000\000A\002D\002\360\000\000D\002J\002\360\000\000J\002K\002\360\000\000K\002T\002\360\000\000T\002_\002\360\000\000_\002d\002\360\000\000d\002j\002\360\000\000j\002k\002\360\000\000k\002t\002\360\000\000t\002u\002\360\000\000u\002A\003\360\000\000A\003B\003\360\000\000B\003Q\003\360\000\000Q\003Y\003\360\000\000Y\003c\003\360\000\000c\003i\003\360\000\000i\003j\003\360\000\000j\003k\003\330\004\025\220Q\320\0260\260\001\330\004\013\2101";
+static const char __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_13[] = "\200\001\360&\000\005\014\210;\220a\220q\330\004\013\210;\220a\220q\330\004\n\210+\220Q\220a\330\004\014\210K\220q\230\001\330\004\r\210]\230!\2306\240\026\240u\250A\330\004\r\210]\230!\2308\240:\250T\260\030\270\032\3004\300x\310z\320Y\\\320\\d\320dn\320ns\320st\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\033/\250q\330\004\021\220\036\230q\240\010\250\001\330\004\021\220\033\230B\230d\240)\250;\260d\270&\300\001\300\031\310+\320UY\320Y_\320_`\320`i\320it\320tw\320w}\320}~\360\000\000\177\001H\002\360\000\000H\002S\002\360\000\000S\002X\002\360\000\000X\002^\002\360\000\000^\002_\002\360\000\000_\002h\002\360\000\000h\002i\002\360\000\000i\002u\002\360\000\000u\002v\002\360\000\000v\002E\003\360\000\000E\003M\003\360\000\000M\003W\003\360\000\000W\003]\003\360\000\000]\003^\003\360\000\000^\003_\003\330\004\025\220Q\220n\240A\330\004\013\2101";
+static const char __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_14[] = "\200\001\360&\000\005\014\210;\220a\220q\330\004\013\210;\220a\220q\330\004\n\210+\220Q\220a\330\004\014\210K\220q\230\001\330\004\r\210]\230!\2306\240\026\240u\250A\330\004\r\210]\230!\2308\240:\250T\260\030\270\032\3004\300x\310z\320Y\\\320\\d\320dn\320ns\320st\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\0335\260Q\330\004\021\220\036\230q\240\010\250\001\330\004\021\320\021\"\240\"\240D\250\t\260\033\270D\300\006\300a\300y\320P[\320[_\320_e\320ef\320fo\320oz\320z}\360\000\000~\001D\002\360\000\000D\002E\002\360\000\000E\002N\002\360\000\000N\002Y\002\360\000\000Y\002^\002\360\000\000^\002d\002\360\000\000d\002e\002\360\000\000e\002n\002\360\000\000n\002o\002\360\000\000o\002{\002\360\000\000{\002|\002\360\000\000|\002K\003\360\000\000K\003S\003\360\000\000S\003]\003\360\000\000]\003c\003\360\000\000c\003d\003\360\000\000d\003e\003\330\004\025\220Q\320\026*\250!\330\004\013\2101";
+static const char __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_15[] = "\200\001\340|}\360&\000\005\014\210;\220a\220q\330\004\013\210;\220a\220q\330\004\n\210+\220Q\220a\330\004\014\210K\220q\230\001\330\004\r\210]\230!\2306\240\026\240u\250A\330\004\r\210]\230!\2308\240:\250T\260\030\270\032\3004\300x\310z\320Y\\\320\\d\320dn\320ns\320st\330\004\r\210U\220'\230\022\2307\240\"\240A\330\004\017\210w\220e\320\0332\260\"\260A\330\004\021\220\036\230q\240\010\250\001\330\004\021\220\036\230r\240\024\240Y\250k\270\024\270V\3001\300I\310[\320X\\\320\\b\320bc\320cl\320lw\320wz\360\000\000{\001A\002\360\000\000A\002B\002\360\000\000B\002K\002\360\000\000K\002V\002\360\000\000V\002[\002\360\000\000[\002a\002\360\000\000a\002b\002\360\000\000b\002k\002\360\000\000k\002y\002\360\000\000y\002z\002\360\000\000z\002F\003\360\000\000F\003G\003\360\000\000G\003V\003\360\000\000V\003^\003\360\000\000^\003h\003\360\000\000h\003n\003\360\000\000n\003o\003\360\000\000o\003p\003\330\004\025\220Q\320\026'\240q\330\004\013\2101";
+/* #### Code section: decls ### */
 static PyObject *__pyx_pf_5talib_7_ta_lib__ta_check_success(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_function_name, TA_RetCode __pyx_v_ret_code); /* proto */
 static PyObject *__pyx_pf_5talib_7_ta_lib_2_ta_initialize(CYTHON_UNUSED PyObject *__pyx_self); /* proto */
 static PyObject *__pyx_pf_5talib_7_ta_lib_4_ta_shutdown(CYTHON_UNUSED PyObject *__pyx_self); /* proto */
@@ -3616,170 +4035,173 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_10_ta_set_compatibility(CYTHON_UNUSED
 static PyObject *__pyx_pf_5talib_7_ta_lib_12_ta_get_compatibility(CYTHON_UNUSED PyObject *__pyx_self); /* proto */
 static PyObject *__pyx_pf_5talib_7_ta_lib_14_ta_set_candle_settings(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_settingtype, PyObject *__pyx_v_rangetype, PyObject *__pyx_v_avgperiod, PyObject *__pyx_v_factor); /* proto */
 static PyObject *__pyx_pf_5talib_7_ta_lib_16_ta_restore_candle_default_settings(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_settingtype); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_18ACOS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_20AD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, PyArrayObject *__pyx_v_volume); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_22ADD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real0, PyArrayObject *__pyx_v_real1); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_24ADOSC(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, PyArrayObject *__pyx_v_volume, int __pyx_v_fastperiod, int __pyx_v_slowperiod); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_26ADX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_28ADXR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_30APO(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_fastperiod, int __pyx_v_slowperiod, int __pyx_v_matype); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_32AROON(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, int __pyx_v_timeperiod); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_34AROONOSC(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, int __pyx_v_timeperiod); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_36ASIN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_38ATAN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_40ATR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_42AVGPRICE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_44BBANDS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod, double __pyx_v_nbdevup, double __pyx_v_nbdevdn, int __pyx_v_matype); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_46BETA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real0, PyArrayObject *__pyx_v_real1, int __pyx_v_timeperiod); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_48BOP(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_50CCI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_52CDL2CROWS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_54CDL3BLACKCROWS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_56CDL3INSIDE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_58CDL3LINESTRIKE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_60CDL3OUTSIDE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_62CDL3STARSINSOUTH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_64CDL3WHITESOLDIERS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_66CDLABANDONEDBABY(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_68CDLADVANCEBLOCK(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_70CDLBELTHOLD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_72CDLBREAKAWAY(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_74CDLCLOSINGMARUBOZU(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_76CDLCONCEALBABYSWALL(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_78CDLCOUNTERATTACK(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_80CDLDARKCLOUDCOVER(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_82CDLDOJI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_84CDLDOJISTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_86CDLDRAGONFLYDOJI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_88CDLENGULFING(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_90CDLEVENINGDOJISTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_92CDLEVENINGSTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_94CDLGAPSIDESIDEWHITE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_96CDLGRAVESTONEDOJI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_98CDLHAMMER(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_100CDLHANGINGMAN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_102CDLHARAMI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_104CDLHARAMICROSS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_106CDLHIGHWAVE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_108CDLHIKKAKE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_110CDLHIKKAKEMOD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_112CDLHOMINGPIGEON(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_114CDLIDENTICAL3CROWS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_116CDLINNECK(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_118CDLINVERTEDHAMMER(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_120CDLKICKING(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_122CDLKICKINGBYLENGTH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_124CDLLADDERBOTTOM(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_126CDLLONGLEGGEDDOJI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_128CDLLONGLINE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_130CDLMARUBOZU(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_132CDLMATCHINGLOW(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_134CDLMATHOLD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_136CDLMORNINGDOJISTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_138CDLMORNINGSTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_140CDLONNECK(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_142CDLPIERCING(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_144CDLRICKSHAWMAN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_146CDLRISEFALL3METHODS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_148CDLSEPARATINGLINES(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_150CDLSHOOTINGSTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_152CDLSHORTLINE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_154CDLSPINNINGTOP(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_156CDLSTALLEDPATTERN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_158CDLSTICKSANDWICH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_160CDLTAKURI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_162CDLTASUKIGAP(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_164CDLTHRUSTING(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_166CDLTRISTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_168CDLUNIQUE3RIVER(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_170CDLUPSIDEGAP2CROWS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_172CDLXSIDEGAP3METHODS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_174CEIL(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_176CMO(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_178CORREL(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real0, PyArrayObject *__pyx_v_real1, int __pyx_v_timeperiod); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_180COS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_182COSH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_184DEMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_186DIV(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real0, PyArrayObject *__pyx_v_real1); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_188DX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_190EMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_192EXP(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_194FLOOR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_196HT_DCPERIOD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_198HT_DCPHASE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_200HT_PHASOR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_202HT_SINE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_204HT_TRENDLINE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_206HT_TRENDMODE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_208KAMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_210LINEARREG(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_212LINEARREG_ANGLE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_214LINEARREG_INTERCEPT(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_216LINEARREG_SLOPE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_218LN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_220LOG10(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_222MA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod, int __pyx_v_matype); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_224MACD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_fastperiod, int __pyx_v_slowperiod, int __pyx_v_signalperiod); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_226MACDEXT(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_fastperiod, int __pyx_v_fastmatype, int __pyx_v_slowperiod, int __pyx_v_slowmatype, int __pyx_v_signalperiod, int __pyx_v_signalmatype); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_228MACDFIX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_signalperiod); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_230MAMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, double __pyx_v_fastlimit, double __pyx_v_slowlimit); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_232MAVP(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, PyArrayObject *__pyx_v_periods, int __pyx_v_minperiod, int __pyx_v_maxperiod, int __pyx_v_matype); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_234MAX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_236MAXINDEX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_238MEDPRICE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_240MFI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, PyArrayObject *__pyx_v_volume, int __pyx_v_timeperiod); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_242MIDPOINT(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_244MIDPRICE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, int __pyx_v_timeperiod); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_246MIN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_248MININDEX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_250MINMAX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_252MINMAXINDEX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_254MINUS_DI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_256MINUS_DM(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, int __pyx_v_timeperiod); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_258MOM(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_260MULT(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real0, PyArrayObject *__pyx_v_real1); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_262NATR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_264OBV(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, PyArrayObject *__pyx_v_volume); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_266PLUS_DI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_268PLUS_DM(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, int __pyx_v_timeperiod); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_270PPO(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_fastperiod, int __pyx_v_slowperiod, int __pyx_v_matype); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_272ROC(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_274ROCP(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_276ROCR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_278ROCR100(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_280RSI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_282SAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, double __pyx_v_acceleration, double __pyx_v_maximum); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_284SAREXT(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, double __pyx_v_startvalue, double __pyx_v_offsetonreverse, double __pyx_v_accelerationinitlong, double __pyx_v_accelerationlong, double __pyx_v_accelerationmaxlong, double __pyx_v_accelerationinitshort, double __pyx_v_accelerationshort, double __pyx_v_accelerationmaxshort); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_286SIN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_288SINH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_290SMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_292SQRT(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_294STDDEV(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod, double __pyx_v_nbdev); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_296STOCH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_fastk_period, int __pyx_v_slowk_period, int __pyx_v_slowk_matype, int __pyx_v_slowd_period, int __pyx_v_slowd_matype); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_298STOCHF(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_fastk_period, int __pyx_v_fastd_period, int __pyx_v_fastd_matype); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_300STOCHRSI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod, int __pyx_v_fastk_period, int __pyx_v_fastd_period, int __pyx_v_fastd_matype); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_302SUB(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real0, PyArrayObject *__pyx_v_real1); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_304SUM(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_306T3(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod, double __pyx_v_vfactor); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_308TAN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_310TANH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_312TEMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_314TRANGE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_316TRIMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_318TRIX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_320TSF(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_322TYPPRICE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_324ULTOSC(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod1, int __pyx_v_timeperiod2, int __pyx_v_timeperiod3); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_326VAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod, double __pyx_v_nbdev); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_328WCLPRICE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_330WILLR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_332WMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_334str2bytes(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_s); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_336bytes2str(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_b); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_338str2bytes(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_s); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_340bytes2str(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_b); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_18ACCBANDS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_20ACOS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_22AD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, PyArrayObject *__pyx_v_volume); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_24ADD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real0, PyArrayObject *__pyx_v_real1); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_26ADOSC(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, PyArrayObject *__pyx_v_volume, int __pyx_v_fastperiod, int __pyx_v_slowperiod); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_28ADX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_30ADXR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_32APO(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_fastperiod, int __pyx_v_slowperiod, int __pyx_v_matype); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_34AROON(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, int __pyx_v_timeperiod); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_36AROONOSC(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, int __pyx_v_timeperiod); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_38ASIN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_40ATAN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_42ATR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_44AVGPRICE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_46AVGDEV(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_48BBANDS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod, double __pyx_v_nbdevup, double __pyx_v_nbdevdn, int __pyx_v_matype); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_50BETA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real0, PyArrayObject *__pyx_v_real1, int __pyx_v_timeperiod); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_52BOP(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_54CCI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_56CDL2CROWS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_58CDL3BLACKCROWS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_60CDL3INSIDE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_62CDL3LINESTRIKE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_64CDL3OUTSIDE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_66CDL3STARSINSOUTH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_68CDL3WHITESOLDIERS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_70CDLABANDONEDBABY(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_72CDLADVANCEBLOCK(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_74CDLBELTHOLD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_76CDLBREAKAWAY(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_78CDLCLOSINGMARUBOZU(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_80CDLCONCEALBABYSWALL(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_82CDLCOUNTERATTACK(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_84CDLDARKCLOUDCOVER(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_86CDLDOJI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_88CDLDOJISTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_90CDLDRAGONFLYDOJI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_92CDLENGULFING(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_94CDLEVENINGDOJISTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_96CDLEVENINGSTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_98CDLGAPSIDESIDEWHITE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_100CDLGRAVESTONEDOJI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_102CDLHAMMER(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_104CDLHANGINGMAN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_106CDLHARAMI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_108CDLHARAMICROSS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_110CDLHIGHWAVE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_112CDLHIKKAKE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_114CDLHIKKAKEMOD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_116CDLHOMINGPIGEON(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_118CDLIDENTICAL3CROWS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_120CDLINNECK(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_122CDLINVERTEDHAMMER(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_124CDLKICKING(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_126CDLKICKINGBYLENGTH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_128CDLLADDERBOTTOM(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_130CDLLONGLEGGEDDOJI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_132CDLLONGLINE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_134CDLMARUBOZU(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_136CDLMATCHINGLOW(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_138CDLMATHOLD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_140CDLMORNINGDOJISTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_142CDLMORNINGSTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_144CDLONNECK(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_146CDLPIERCING(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_148CDLRICKSHAWMAN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_150CDLRISEFALL3METHODS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_152CDLSEPARATINGLINES(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_154CDLSHOOTINGSTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_156CDLSHORTLINE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_158CDLSPINNINGTOP(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_160CDLSTALLEDPATTERN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_162CDLSTICKSANDWICH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_164CDLTAKURI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_166CDLTASUKIGAP(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_168CDLTHRUSTING(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_170CDLTRISTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_172CDLUNIQUE3RIVER(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_174CDLUPSIDEGAP2CROWS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_176CDLXSIDEGAP3METHODS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_178CEIL(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_180CMO(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_182CORREL(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real0, PyArrayObject *__pyx_v_real1, int __pyx_v_timeperiod); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_184COS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_186COSH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_188DEMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_190DIV(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real0, PyArrayObject *__pyx_v_real1); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_192DX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_194EMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_196EXP(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_198FLOOR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_200HT_DCPERIOD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_202HT_DCPHASE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_204HT_PHASOR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_206HT_SINE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_208HT_TRENDLINE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_210HT_TRENDMODE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_212IMI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_214KAMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_216LINEARREG(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_218LINEARREG_ANGLE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_220LINEARREG_INTERCEPT(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_222LINEARREG_SLOPE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_224LN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_226LOG10(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_228MA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod, int __pyx_v_matype); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_230MACD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_fastperiod, int __pyx_v_slowperiod, int __pyx_v_signalperiod); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_232MACDEXT(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_fastperiod, int __pyx_v_fastmatype, int __pyx_v_slowperiod, int __pyx_v_slowmatype, int __pyx_v_signalperiod, int __pyx_v_signalmatype); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_234MACDFIX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_signalperiod); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_236MAMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, double __pyx_v_fastlimit, double __pyx_v_slowlimit); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_238MAVP(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, PyArrayObject *__pyx_v_periods, int __pyx_v_minperiod, int __pyx_v_maxperiod, int __pyx_v_matype); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_240MAX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_242MAXINDEX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_244MEDPRICE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_246MFI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, PyArrayObject *__pyx_v_volume, int __pyx_v_timeperiod); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_248MIDPOINT(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_250MIDPRICE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, int __pyx_v_timeperiod); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_252MIN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_254MININDEX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_256MINMAX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_258MINMAXINDEX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_260MINUS_DI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_262MINUS_DM(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, int __pyx_v_timeperiod); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_264MOM(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_266MULT(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real0, PyArrayObject *__pyx_v_real1); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_268NATR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_270OBV(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, PyArrayObject *__pyx_v_volume); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_272PLUS_DI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_274PLUS_DM(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, int __pyx_v_timeperiod); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_276PPO(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_fastperiod, int __pyx_v_slowperiod, int __pyx_v_matype); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_278ROC(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_280ROCP(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_282ROCR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_284ROCR100(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_286RSI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_288SAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, double __pyx_v_acceleration, double __pyx_v_maximum); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_290SAREXT(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, double __pyx_v_startvalue, double __pyx_v_offsetonreverse, double __pyx_v_accelerationinitlong, double __pyx_v_accelerationlong, double __pyx_v_accelerationmaxlong, double __pyx_v_accelerationinitshort, double __pyx_v_accelerationshort, double __pyx_v_accelerationmaxshort); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_292SIN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_294SINH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_296SMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_298SQRT(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_300STDDEV(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod, double __pyx_v_nbdev); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_302STOCH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_fastk_period, int __pyx_v_slowk_period, int __pyx_v_slowk_matype, int __pyx_v_slowd_period, int __pyx_v_slowd_matype); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_304STOCHF(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_fastk_period, int __pyx_v_fastd_period, int __pyx_v_fastd_matype); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_306STOCHRSI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod, int __pyx_v_fastk_period, int __pyx_v_fastd_period, int __pyx_v_fastd_matype); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_308SUB(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real0, PyArrayObject *__pyx_v_real1); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_310SUM(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_312T3(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod, double __pyx_v_vfactor); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_314TAN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_316TANH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_318TEMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_320TRANGE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_322TRIMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_324TRIX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_326TSF(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_328TYPPRICE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_330ULTOSC(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod1, int __pyx_v_timeperiod2, int __pyx_v_timeperiod3); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_332VAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod, double __pyx_v_nbdev); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_334WCLPRICE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_336WILLR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_338WMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_340str2bytes(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_s); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_342bytes2str(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_b); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_344str2bytes(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_s); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_346bytes2str(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_b); /* proto */
 static PyObject *__pyx_pf_5talib_7_ta_lib_8Function___init__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_function_name, PyObject *__pyx_v_func_object, PyObject *__pyx_v_args, PyObject *__pyx_v_kwargs); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_2__initialize_function_info(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_2__local(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self); /* proto */
 static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_4info(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self); /* proto */
 static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_6function_flags(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self); /* proto */
 static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_8output_flags(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self); /* proto */
@@ -3802,1492 +4224,1688 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_40__get_opt_input_value(CYTH
 static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_42__repr__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self); /* proto */
 static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_44__unicode__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self); /* proto */
 static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_46__str__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_342_ta_getGroupTable(CYTHON_UNUSED PyObject *__pyx_self); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_344_ta_getFuncTable(CYTHON_UNUSED PyObject *__pyx_self, char *__pyx_v_group); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_346__get_flags(CYTHON_UNUSED PyObject *__pyx_self, int __pyx_v_flag, PyObject *__pyx_v_flags_lookup_dict); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_348_ta_getFuncInfo(CYTHON_UNUSED PyObject *__pyx_self, char *__pyx_v_function_name); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_350_ta_getInputParameterInfo(CYTHON_UNUSED PyObject *__pyx_self, char *__pyx_v_function_name, int __pyx_v_idx); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_352_ta_getOptInputParameterInfo(CYTHON_UNUSED PyObject *__pyx_self, char *__pyx_v_function_name, int __pyx_v_idx); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_354_ta_getOutputParameterInfo(CYTHON_UNUSED PyObject *__pyx_self, char *__pyx_v_function_name, int __pyx_v_idx); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_356_get_defaults_and_docs(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_func_info); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_358stream_ACOS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_360stream_AD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, PyArrayObject *__pyx_v_volume); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_362stream_ADD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real0, PyArrayObject *__pyx_v_real1); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_364stream_ADOSC(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, PyArrayObject *__pyx_v_volume, int __pyx_v_fastperiod, int __pyx_v_slowperiod); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_366stream_ADX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_368stream_ADXR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_370stream_APO(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_fastperiod, int __pyx_v_slowperiod, int __pyx_v_matype); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_372stream_AROON(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, int __pyx_v_timeperiod); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_374stream_AROONOSC(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, int __pyx_v_timeperiod); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_376stream_ASIN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_378stream_ATAN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_380stream_ATR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_382stream_AVGPRICE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_384stream_BBANDS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod, double __pyx_v_nbdevup, double __pyx_v_nbdevdn, int __pyx_v_matype); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_386stream_BETA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real0, PyArrayObject *__pyx_v_real1, int __pyx_v_timeperiod); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_388stream_BOP(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_390stream_CCI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_392stream_CDL2CROWS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_394stream_CDL3BLACKCROWS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_396stream_CDL3INSIDE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_398stream_CDL3LINESTRIKE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_400stream_CDL3OUTSIDE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_402stream_CDL3STARSINSOUTH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_404stream_CDL3WHITESOLDIERS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_406stream_CDLABANDONEDBABY(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_408stream_CDLADVANCEBLOCK(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_410stream_CDLBELTHOLD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_412stream_CDLBREAKAWAY(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_414stream_CDLCLOSINGMARUBOZU(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_416stream_CDLCONCEALBABYSWALL(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_418stream_CDLCOUNTERATTACK(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_420stream_CDLDARKCLOUDCOVER(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_422stream_CDLDOJI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_424stream_CDLDOJISTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_426stream_CDLDRAGONFLYDOJI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_428stream_CDLENGULFING(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_430stream_CDLEVENINGDOJISTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_432stream_CDLEVENINGSTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_434stream_CDLGAPSIDESIDEWHITE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_436stream_CDLGRAVESTONEDOJI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_438stream_CDLHAMMER(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_440stream_CDLHANGINGMAN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_442stream_CDLHARAMI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_444stream_CDLHARAMICROSS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_446stream_CDLHIGHWAVE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_448stream_CDLHIKKAKE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_450stream_CDLHIKKAKEMOD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_452stream_CDLHOMINGPIGEON(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_454stream_CDLIDENTICAL3CROWS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_456stream_CDLINNECK(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_458stream_CDLINVERTEDHAMMER(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_460stream_CDLKICKING(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_462stream_CDLKICKINGBYLENGTH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_464stream_CDLLADDERBOTTOM(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_466stream_CDLLONGLEGGEDDOJI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_468stream_CDLLONGLINE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_470stream_CDLMARUBOZU(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_472stream_CDLMATCHINGLOW(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_474stream_CDLMATHOLD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_476stream_CDLMORNINGDOJISTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_478stream_CDLMORNINGSTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_480stream_CDLONNECK(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_482stream_CDLPIERCING(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_484stream_CDLRICKSHAWMAN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_486stream_CDLRISEFALL3METHODS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_488stream_CDLSEPARATINGLINES(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_490stream_CDLSHOOTINGSTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_492stream_CDLSHORTLINE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_494stream_CDLSPINNINGTOP(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_496stream_CDLSTALLEDPATTERN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_498stream_CDLSTICKSANDWICH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_500stream_CDLTAKURI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_502stream_CDLTASUKIGAP(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_504stream_CDLTHRUSTING(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_506stream_CDLTRISTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_508stream_CDLUNIQUE3RIVER(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_510stream_CDLUPSIDEGAP2CROWS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_512stream_CDLXSIDEGAP3METHODS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_514stream_CEIL(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_516stream_CMO(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_518stream_CORREL(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real0, PyArrayObject *__pyx_v_real1, int __pyx_v_timeperiod); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_520stream_COS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_522stream_COSH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_524stream_DEMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_526stream_DIV(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real0, PyArrayObject *__pyx_v_real1); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_528stream_DX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_530stream_EMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_532stream_EXP(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_534stream_FLOOR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_536stream_HT_DCPERIOD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_538stream_HT_DCPHASE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_540stream_HT_PHASOR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_542stream_HT_SINE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_544stream_HT_TRENDLINE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_546stream_HT_TRENDMODE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_548stream_KAMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_550stream_LINEARREG(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_552stream_LINEARREG_ANGLE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_554stream_LINEARREG_INTERCEPT(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_556stream_LINEARREG_SLOPE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_558stream_LN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_560stream_LOG10(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_562stream_MA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod, int __pyx_v_matype); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_564stream_MACD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_fastperiod, int __pyx_v_slowperiod, int __pyx_v_signalperiod); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_566stream_MACDEXT(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_fastperiod, int __pyx_v_fastmatype, int __pyx_v_slowperiod, int __pyx_v_slowmatype, int __pyx_v_signalperiod, int __pyx_v_signalmatype); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_568stream_MACDFIX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_signalperiod); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_570stream_MAMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, double __pyx_v_fastlimit, double __pyx_v_slowlimit); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_572stream_MAVP(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, PyArrayObject *__pyx_v_periods, int __pyx_v_minperiod, int __pyx_v_maxperiod, int __pyx_v_matype); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_574stream_MAX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_576stream_MAXINDEX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_578stream_MEDPRICE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_580stream_MFI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, PyArrayObject *__pyx_v_volume, int __pyx_v_timeperiod); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_582stream_MIDPOINT(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_584stream_MIDPRICE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, int __pyx_v_timeperiod); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_586stream_MIN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_588stream_MININDEX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_590stream_MINMAX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_592stream_MINMAXINDEX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_594stream_MINUS_DI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_596stream_MINUS_DM(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, int __pyx_v_timeperiod); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_598stream_MOM(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_600stream_MULT(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real0, PyArrayObject *__pyx_v_real1); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_602stream_NATR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_604stream_OBV(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, PyArrayObject *__pyx_v_volume); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_606stream_PLUS_DI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_608stream_PLUS_DM(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, int __pyx_v_timeperiod); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_610stream_PPO(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_fastperiod, int __pyx_v_slowperiod, int __pyx_v_matype); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_612stream_ROC(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_614stream_ROCP(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_616stream_ROCR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_618stream_ROCR100(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_620stream_RSI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_622stream_SAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, double __pyx_v_acceleration, double __pyx_v_maximum); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_624stream_SAREXT(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, double __pyx_v_startvalue, double __pyx_v_offsetonreverse, double __pyx_v_accelerationinitlong, double __pyx_v_accelerationlong, double __pyx_v_accelerationmaxlong, double __pyx_v_accelerationinitshort, double __pyx_v_accelerationshort, double __pyx_v_accelerationmaxshort); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_626stream_SIN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_628stream_SINH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_630stream_SMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_632stream_SQRT(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_634stream_STDDEV(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod, double __pyx_v_nbdev); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_636stream_STOCH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_fastk_period, int __pyx_v_slowk_period, int __pyx_v_slowk_matype, int __pyx_v_slowd_period, int __pyx_v_slowd_matype); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_638stream_STOCHF(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_fastk_period, int __pyx_v_fastd_period, int __pyx_v_fastd_matype); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_640stream_STOCHRSI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod, int __pyx_v_fastk_period, int __pyx_v_fastd_period, int __pyx_v_fastd_matype); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_642stream_SUB(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real0, PyArrayObject *__pyx_v_real1); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_644stream_SUM(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_646stream_T3(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod, double __pyx_v_vfactor); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_648stream_TAN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_650stream_TANH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_652stream_TEMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_654stream_TRANGE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_656stream_TRIMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_658stream_TRIX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_660stream_TSF(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_662stream_TYPPRICE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_664stream_ULTOSC(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod1, int __pyx_v_timeperiod2, int __pyx_v_timeperiod3); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_666stream_VAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod, double __pyx_v_nbdev); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_668stream_WCLPRICE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_670stream_WILLR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod); /* proto */
-static PyObject *__pyx_pf_5talib_7_ta_lib_672stream_WMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* 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 __Pyx_CachedCFunction __pyx_umethod_PyDict_Type_keys = {0, &__pyx_n_s_keys, 0, 0, 0};
-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_8;
-static PyObject *__pyx_int_9;
-static PyObject *__pyx_int_12;
-static PyObject *__pyx_int_16;
-static PyObject *__pyx_int_32;
-static PyObject *__pyx_int_64;
-static PyObject *__pyx_int_128;
-static PyObject *__pyx_int_256;
-static PyObject *__pyx_int_512;
-static PyObject *__pyx_int_1024;
-static PyObject *__pyx_int_2048;
-static PyObject *__pyx_int_4096;
-static PyObject *__pyx_int_16777216;
-static PyObject *__pyx_int_67108864;
-static PyObject *__pyx_int_134217728;
-static PyObject *__pyx_int_268435456;
-static PyObject *__pyx_int_neg_1;
-static PyObject *__pyx_tuple_;
-static PyObject *__pyx_tuple__2;
-static PyObject *__pyx_tuple__3;
-static PyObject *__pyx_tuple__4;
-static PyObject *__pyx_tuple__7;
-static PyObject *__pyx_tuple__12;
-static PyObject *__pyx_tuple__13;
-static PyObject *__pyx_tuple__14;
-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__21;
-static PyObject *__pyx_tuple__23;
-static PyObject *__pyx_tuple__24;
-static PyObject *__pyx_tuple__25;
-static PyObject *__pyx_tuple__27;
-static PyObject *__pyx_tuple__29;
-static PyObject *__pyx_tuple__31;
-static PyObject *__pyx_tuple__33;
-static PyObject *__pyx_tuple__35;
-static PyObject *__pyx_tuple__37;
-static PyObject *__pyx_tuple__38;
-static PyObject *__pyx_tuple__39;
-static PyObject *__pyx_tuple__40;
-static PyObject *__pyx_tuple__41;
-static PyObject *__pyx_tuple__43;
-static PyObject *__pyx_tuple__45;
-static PyObject *__pyx_tuple__47;
-static PyObject *__pyx_tuple__49;
-static PyObject *__pyx_tuple__51;
-static PyObject *__pyx_tuple__53;
-static PyObject *__pyx_tuple__55;
-static PyObject *__pyx_tuple__57;
-static PyObject *__pyx_tuple__59;
-static PyObject *__pyx_tuple__61;
-static PyObject *__pyx_tuple__63;
-static PyObject *__pyx_tuple__65;
-static PyObject *__pyx_tuple__67;
-static PyObject *__pyx_tuple__69;
-static PyObject *__pyx_tuple__71;
-static PyObject *__pyx_tuple__73;
-static PyObject *__pyx_tuple__75;
-static PyObject *__pyx_tuple__77;
-static PyObject *__pyx_tuple__79;
-static PyObject *__pyx_tuple__81;
-static PyObject *__pyx_tuple__83;
-static PyObject *__pyx_tuple__85;
-static PyObject *__pyx_tuple__87;
-static PyObject *__pyx_tuple__89;
-static PyObject *__pyx_tuple__91;
-static PyObject *__pyx_tuple__93;
-static PyObject *__pyx_tuple__95;
-static PyObject *__pyx_tuple__97;
-static PyObject *__pyx_tuple__99;
-static PyObject *__pyx_tuple__101;
-static PyObject *__pyx_tuple__103;
-static PyObject *__pyx_tuple__105;
-static PyObject *__pyx_tuple__107;
-static PyObject *__pyx_tuple__109;
-static PyObject *__pyx_tuple__111;
-static PyObject *__pyx_tuple__113;
-static PyObject *__pyx_tuple__115;
-static PyObject *__pyx_tuple__117;
-static PyObject *__pyx_tuple__119;
-static PyObject *__pyx_tuple__121;
-static PyObject *__pyx_tuple__123;
-static PyObject *__pyx_tuple__125;
-static PyObject *__pyx_tuple__127;
-static PyObject *__pyx_tuple__129;
-static PyObject *__pyx_tuple__131;
-static PyObject *__pyx_tuple__133;
-static PyObject *__pyx_tuple__135;
-static PyObject *__pyx_tuple__137;
-static PyObject *__pyx_tuple__139;
-static PyObject *__pyx_tuple__141;
-static PyObject *__pyx_tuple__143;
-static PyObject *__pyx_tuple__145;
-static PyObject *__pyx_tuple__147;
-static PyObject *__pyx_tuple__149;
-static PyObject *__pyx_tuple__151;
-static PyObject *__pyx_tuple__153;
-static PyObject *__pyx_tuple__155;
-static PyObject *__pyx_tuple__157;
-static PyObject *__pyx_tuple__159;
-static PyObject *__pyx_tuple__161;
-static PyObject *__pyx_tuple__163;
-static PyObject *__pyx_tuple__165;
-static PyObject *__pyx_tuple__167;
-static PyObject *__pyx_tuple__169;
-static PyObject *__pyx_tuple__171;
-static PyObject *__pyx_tuple__173;
-static PyObject *__pyx_tuple__175;
-static PyObject *__pyx_tuple__177;
-static PyObject *__pyx_tuple__179;
-static PyObject *__pyx_tuple__181;
-static PyObject *__pyx_tuple__183;
-static PyObject *__pyx_tuple__185;
-static PyObject *__pyx_tuple__187;
-static PyObject *__pyx_tuple__189;
-static PyObject *__pyx_tuple__191;
-static PyObject *__pyx_tuple__193;
-static PyObject *__pyx_tuple__195;
-static PyObject *__pyx_tuple__197;
-static PyObject *__pyx_tuple__199;
-static PyObject *__pyx_tuple__201;
-static PyObject *__pyx_tuple__203;
-static PyObject *__pyx_tuple__205;
-static PyObject *__pyx_tuple__207;
-static PyObject *__pyx_tuple__209;
-static PyObject *__pyx_tuple__211;
-static PyObject *__pyx_tuple__213;
-static PyObject *__pyx_tuple__215;
-static PyObject *__pyx_tuple__217;
-static PyObject *__pyx_tuple__219;
-static PyObject *__pyx_tuple__221;
-static PyObject *__pyx_tuple__223;
-static PyObject *__pyx_tuple__225;
-static PyObject *__pyx_tuple__227;
-static PyObject *__pyx_tuple__229;
-static PyObject *__pyx_tuple__231;
-static PyObject *__pyx_tuple__233;
-static PyObject *__pyx_tuple__235;
-static PyObject *__pyx_tuple__237;
-static PyObject *__pyx_tuple__239;
-static PyObject *__pyx_tuple__241;
-static PyObject *__pyx_tuple__243;
-static PyObject *__pyx_tuple__245;
-static PyObject *__pyx_tuple__247;
-static PyObject *__pyx_tuple__249;
-static PyObject *__pyx_tuple__251;
-static PyObject *__pyx_tuple__253;
-static PyObject *__pyx_tuple__255;
-static PyObject *__pyx_tuple__257;
-static PyObject *__pyx_tuple__259;
-static PyObject *__pyx_tuple__261;
-static PyObject *__pyx_tuple__263;
-static PyObject *__pyx_tuple__265;
-static PyObject *__pyx_tuple__267;
-static PyObject *__pyx_tuple__269;
-static PyObject *__pyx_tuple__271;
-static PyObject *__pyx_tuple__273;
-static PyObject *__pyx_tuple__275;
-static PyObject *__pyx_tuple__277;
-static PyObject *__pyx_tuple__279;
-static PyObject *__pyx_tuple__281;
-static PyObject *__pyx_tuple__283;
-static PyObject *__pyx_tuple__285;
-static PyObject *__pyx_tuple__287;
-static PyObject *__pyx_tuple__289;
-static PyObject *__pyx_tuple__291;
-static PyObject *__pyx_tuple__293;
-static PyObject *__pyx_tuple__295;
-static PyObject *__pyx_tuple__297;
-static PyObject *__pyx_tuple__299;
-static PyObject *__pyx_tuple__301;
-static PyObject *__pyx_tuple__303;
-static PyObject *__pyx_tuple__305;
-static PyObject *__pyx_tuple__307;
-static PyObject *__pyx_tuple__309;
-static PyObject *__pyx_tuple__311;
-static PyObject *__pyx_tuple__313;
-static PyObject *__pyx_tuple__315;
-static PyObject *__pyx_tuple__317;
-static PyObject *__pyx_tuple__319;
-static PyObject *__pyx_tuple__321;
-static PyObject *__pyx_tuple__323;
-static PyObject *__pyx_tuple__325;
-static PyObject *__pyx_tuple__327;
-static PyObject *__pyx_tuple__329;
-static PyObject *__pyx_tuple__331;
-static PyObject *__pyx_tuple__333;
-static PyObject *__pyx_tuple__335;
-static PyObject *__pyx_tuple__337;
-static PyObject *__pyx_tuple__339;
-static PyObject *__pyx_tuple__341;
-static PyObject *__pyx_tuple__343;
-static PyObject *__pyx_tuple__345;
-static PyObject *__pyx_tuple__347;
-static PyObject *__pyx_tuple__349;
-static PyObject *__pyx_tuple__351;
-static PyObject *__pyx_tuple__353;
-static PyObject *__pyx_tuple__355;
-static PyObject *__pyx_tuple__357;
-static PyObject *__pyx_tuple__359;
-static PyObject *__pyx_tuple__361;
-static PyObject *__pyx_tuple__363;
-static PyObject *__pyx_tuple__365;
-static PyObject *__pyx_tuple__367;
-static PyObject *__pyx_tuple__369;
-static PyObject *__pyx_tuple__370;
-static PyObject *__pyx_tuple__372;
-static PyObject *__pyx_tuple__374;
-static PyObject *__pyx_tuple__376;
-static PyObject *__pyx_tuple__378;
-static PyObject *__pyx_tuple__380;
-static PyObject *__pyx_tuple__382;
-static PyObject *__pyx_tuple__384;
-static PyObject *__pyx_tuple__386;
-static PyObject *__pyx_tuple__388;
-static PyObject *__pyx_tuple__390;
-static PyObject *__pyx_tuple__392;
-static PyObject *__pyx_tuple__393;
-static PyObject *__pyx_tuple__395;
-static PyObject *__pyx_tuple__397;
-static PyObject *__pyx_tuple__399;
-static PyObject *__pyx_tuple__401;
-static PyObject *__pyx_tuple__403;
-static PyObject *__pyx_tuple__404;
-static PyObject *__pyx_tuple__406;
-static PyObject *__pyx_tuple__408;
-static PyObject *__pyx_tuple__410;
-static PyObject *__pyx_tuple__412;
-static PyObject *__pyx_tuple__414;
-static PyObject *__pyx_tuple__416;
-static PyObject *__pyx_tuple__418;
-static PyObject *__pyx_tuple__420;
-static PyObject *__pyx_tuple__422;
-static PyObject *__pyx_tuple__424;
-static PyObject *__pyx_tuple__426;
-static PyObject *__pyx_tuple__428;
-static PyObject *__pyx_tuple__430;
-static PyObject *__pyx_tuple__432;
-static PyObject *__pyx_tuple__434;
-static PyObject *__pyx_tuple__436;
-static PyObject *__pyx_tuple__438;
-static PyObject *__pyx_tuple__440;
-static PyObject *__pyx_tuple__442;
-static PyObject *__pyx_tuple__444;
-static PyObject *__pyx_tuple__446;
-static PyObject *__pyx_tuple__448;
-static PyObject *__pyx_tuple__450;
-static PyObject *__pyx_tuple__452;
-static PyObject *__pyx_tuple__454;
-static PyObject *__pyx_tuple__456;
-static PyObject *__pyx_tuple__458;
-static PyObject *__pyx_tuple__460;
-static PyObject *__pyx_tuple__462;
-static PyObject *__pyx_tuple__464;
-static PyObject *__pyx_tuple__466;
-static PyObject *__pyx_tuple__468;
-static PyObject *__pyx_tuple__470;
-static PyObject *__pyx_tuple__472;
-static PyObject *__pyx_tuple__474;
-static PyObject *__pyx_tuple__476;
-static PyObject *__pyx_tuple__478;
-static PyObject *__pyx_tuple__480;
-static PyObject *__pyx_tuple__482;
-static PyObject *__pyx_tuple__484;
-static PyObject *__pyx_tuple__486;
-static PyObject *__pyx_tuple__488;
-static PyObject *__pyx_tuple__490;
-static PyObject *__pyx_tuple__492;
-static PyObject *__pyx_tuple__494;
-static PyObject *__pyx_tuple__496;
-static PyObject *__pyx_tuple__498;
-static PyObject *__pyx_tuple__500;
-static PyObject *__pyx_tuple__502;
-static PyObject *__pyx_tuple__504;
-static PyObject *__pyx_tuple__506;
-static PyObject *__pyx_tuple__508;
-static PyObject *__pyx_tuple__510;
-static PyObject *__pyx_tuple__512;
-static PyObject *__pyx_tuple__514;
-static PyObject *__pyx_tuple__516;
-static PyObject *__pyx_tuple__518;
-static PyObject *__pyx_tuple__520;
-static PyObject *__pyx_tuple__522;
-static PyObject *__pyx_tuple__524;
-static PyObject *__pyx_tuple__526;
-static PyObject *__pyx_tuple__528;
-static PyObject *__pyx_tuple__530;
-static PyObject *__pyx_tuple__532;
-static PyObject *__pyx_tuple__534;
-static PyObject *__pyx_tuple__536;
-static PyObject *__pyx_tuple__538;
-static PyObject *__pyx_tuple__540;
-static PyObject *__pyx_tuple__542;
-static PyObject *__pyx_tuple__544;
-static PyObject *__pyx_tuple__546;
-static PyObject *__pyx_tuple__548;
-static PyObject *__pyx_tuple__550;
-static PyObject *__pyx_tuple__552;
-static PyObject *__pyx_tuple__554;
-static PyObject *__pyx_tuple__556;
-static PyObject *__pyx_tuple__558;
-static PyObject *__pyx_tuple__560;
-static PyObject *__pyx_tuple__562;
-static PyObject *__pyx_tuple__564;
-static PyObject *__pyx_tuple__566;
-static PyObject *__pyx_tuple__568;
-static PyObject *__pyx_tuple__570;
-static PyObject *__pyx_tuple__572;
-static PyObject *__pyx_tuple__574;
-static PyObject *__pyx_tuple__576;
-static PyObject *__pyx_tuple__578;
-static PyObject *__pyx_tuple__580;
-static PyObject *__pyx_tuple__582;
-static PyObject *__pyx_tuple__584;
-static PyObject *__pyx_tuple__586;
-static PyObject *__pyx_tuple__588;
-static PyObject *__pyx_tuple__590;
-static PyObject *__pyx_tuple__592;
-static PyObject *__pyx_tuple__594;
-static PyObject *__pyx_tuple__596;
-static PyObject *__pyx_tuple__598;
-static PyObject *__pyx_tuple__600;
-static PyObject *__pyx_tuple__602;
-static PyObject *__pyx_tuple__604;
-static PyObject *__pyx_tuple__606;
-static PyObject *__pyx_tuple__608;
-static PyObject *__pyx_tuple__610;
-static PyObject *__pyx_tuple__612;
-static PyObject *__pyx_tuple__614;
-static PyObject *__pyx_tuple__616;
-static PyObject *__pyx_tuple__618;
-static PyObject *__pyx_tuple__620;
-static PyObject *__pyx_tuple__622;
-static PyObject *__pyx_tuple__624;
-static PyObject *__pyx_tuple__626;
-static PyObject *__pyx_tuple__628;
-static PyObject *__pyx_tuple__630;
-static PyObject *__pyx_tuple__632;
-static PyObject *__pyx_tuple__634;
-static PyObject *__pyx_tuple__636;
-static PyObject *__pyx_tuple__638;
-static PyObject *__pyx_tuple__640;
-static PyObject *__pyx_tuple__642;
-static PyObject *__pyx_tuple__644;
-static PyObject *__pyx_tuple__646;
-static PyObject *__pyx_tuple__648;
-static PyObject *__pyx_tuple__650;
-static PyObject *__pyx_tuple__652;
-static PyObject *__pyx_tuple__654;
-static PyObject *__pyx_tuple__656;
-static PyObject *__pyx_tuple__658;
-static PyObject *__pyx_tuple__660;
-static PyObject *__pyx_tuple__662;
-static PyObject *__pyx_tuple__664;
-static PyObject *__pyx_tuple__666;
-static PyObject *__pyx_tuple__668;
-static PyObject *__pyx_tuple__670;
-static PyObject *__pyx_tuple__672;
-static PyObject *__pyx_tuple__674;
-static PyObject *__pyx_tuple__676;
-static PyObject *__pyx_tuple__678;
-static PyObject *__pyx_tuple__680;
-static PyObject *__pyx_tuple__682;
-static PyObject *__pyx_tuple__684;
-static PyObject *__pyx_tuple__686;
-static PyObject *__pyx_tuple__688;
-static PyObject *__pyx_tuple__690;
-static PyObject *__pyx_tuple__692;
-static PyObject *__pyx_tuple__694;
-static PyObject *__pyx_tuple__696;
-static PyObject *__pyx_tuple__698;
-static PyObject *__pyx_tuple__700;
-static PyObject *__pyx_tuple__702;
-static PyObject *__pyx_tuple__704;
-static PyObject *__pyx_tuple__706;
-static PyObject *__pyx_tuple__708;
-static PyObject *__pyx_tuple__710;
-static PyObject *__pyx_tuple__712;
-static PyObject *__pyx_tuple__714;
-static PyObject *__pyx_tuple__716;
-static PyObject *__pyx_tuple__718;
-static PyObject *__pyx_tuple__720;
-static PyObject *__pyx_tuple__722;
-static PyObject *__pyx_tuple__724;
-static PyObject *__pyx_tuple__726;
-static PyObject *__pyx_tuple__728;
-static PyObject *__pyx_tuple__730;
-static PyObject *__pyx_tuple__732;
-static PyObject *__pyx_tuple__734;
-static PyObject *__pyx_tuple__736;
-static PyObject *__pyx_tuple__738;
-static PyObject *__pyx_tuple__740;
-static PyObject *__pyx_tuple__742;
-static PyObject *__pyx_tuple__744;
-static PyObject *__pyx_tuple__746;
-static PyObject *__pyx_tuple__748;
-static PyObject *__pyx_tuple__750;
-static PyObject *__pyx_codeobj__20;
-static PyObject *__pyx_codeobj__22;
-static PyObject *__pyx_codeobj__26;
-static PyObject *__pyx_codeobj__28;
-static PyObject *__pyx_codeobj__30;
-static PyObject *__pyx_codeobj__32;
-static PyObject *__pyx_codeobj__34;
-static PyObject *__pyx_codeobj__36;
-static PyObject *__pyx_codeobj__42;
-static PyObject *__pyx_codeobj__44;
-static PyObject *__pyx_codeobj__46;
-static PyObject *__pyx_codeobj__48;
-static PyObject *__pyx_codeobj__50;
-static PyObject *__pyx_codeobj__52;
-static PyObject *__pyx_codeobj__54;
-static PyObject *__pyx_codeobj__56;
-static PyObject *__pyx_codeobj__58;
-static PyObject *__pyx_codeobj__60;
-static PyObject *__pyx_codeobj__62;
-static PyObject *__pyx_codeobj__64;
-static PyObject *__pyx_codeobj__66;
-static PyObject *__pyx_codeobj__68;
-static PyObject *__pyx_codeobj__70;
-static PyObject *__pyx_codeobj__72;
-static PyObject *__pyx_codeobj__74;
-static PyObject *__pyx_codeobj__76;
-static PyObject *__pyx_codeobj__78;
-static PyObject *__pyx_codeobj__80;
-static PyObject *__pyx_codeobj__82;
-static PyObject *__pyx_codeobj__84;
-static PyObject *__pyx_codeobj__86;
-static PyObject *__pyx_codeobj__88;
-static PyObject *__pyx_codeobj__90;
-static PyObject *__pyx_codeobj__92;
-static PyObject *__pyx_codeobj__94;
-static PyObject *__pyx_codeobj__96;
-static PyObject *__pyx_codeobj__98;
-static PyObject *__pyx_codeobj__100;
-static PyObject *__pyx_codeobj__102;
-static PyObject *__pyx_codeobj__104;
-static PyObject *__pyx_codeobj__106;
-static PyObject *__pyx_codeobj__108;
-static PyObject *__pyx_codeobj__110;
-static PyObject *__pyx_codeobj__112;
-static PyObject *__pyx_codeobj__114;
-static PyObject *__pyx_codeobj__116;
-static PyObject *__pyx_codeobj__118;
-static PyObject *__pyx_codeobj__120;
-static PyObject *__pyx_codeobj__122;
-static PyObject *__pyx_codeobj__124;
-static PyObject *__pyx_codeobj__126;
-static PyObject *__pyx_codeobj__128;
-static PyObject *__pyx_codeobj__130;
-static PyObject *__pyx_codeobj__132;
-static PyObject *__pyx_codeobj__134;
-static PyObject *__pyx_codeobj__136;
-static PyObject *__pyx_codeobj__138;
-static PyObject *__pyx_codeobj__140;
-static PyObject *__pyx_codeobj__142;
-static PyObject *__pyx_codeobj__144;
-static PyObject *__pyx_codeobj__146;
-static PyObject *__pyx_codeobj__148;
-static PyObject *__pyx_codeobj__150;
-static PyObject *__pyx_codeobj__152;
-static PyObject *__pyx_codeobj__154;
-static PyObject *__pyx_codeobj__156;
-static PyObject *__pyx_codeobj__158;
-static PyObject *__pyx_codeobj__160;
-static PyObject *__pyx_codeobj__162;
-static PyObject *__pyx_codeobj__164;
-static PyObject *__pyx_codeobj__166;
-static PyObject *__pyx_codeobj__168;
-static PyObject *__pyx_codeobj__170;
-static PyObject *__pyx_codeobj__172;
-static PyObject *__pyx_codeobj__174;
-static PyObject *__pyx_codeobj__176;
-static PyObject *__pyx_codeobj__178;
-static PyObject *__pyx_codeobj__180;
-static PyObject *__pyx_codeobj__182;
-static PyObject *__pyx_codeobj__184;
-static PyObject *__pyx_codeobj__186;
-static PyObject *__pyx_codeobj__188;
-static PyObject *__pyx_codeobj__190;
-static PyObject *__pyx_codeobj__192;
-static PyObject *__pyx_codeobj__194;
-static PyObject *__pyx_codeobj__196;
-static PyObject *__pyx_codeobj__198;
-static PyObject *__pyx_codeobj__200;
-static PyObject *__pyx_codeobj__202;
-static PyObject *__pyx_codeobj__204;
-static PyObject *__pyx_codeobj__206;
-static PyObject *__pyx_codeobj__208;
-static PyObject *__pyx_codeobj__210;
-static PyObject *__pyx_codeobj__212;
-static PyObject *__pyx_codeobj__214;
-static PyObject *__pyx_codeobj__216;
-static PyObject *__pyx_codeobj__218;
-static PyObject *__pyx_codeobj__220;
-static PyObject *__pyx_codeobj__222;
-static PyObject *__pyx_codeobj__224;
-static PyObject *__pyx_codeobj__226;
-static PyObject *__pyx_codeobj__228;
-static PyObject *__pyx_codeobj__230;
-static PyObject *__pyx_codeobj__232;
-static PyObject *__pyx_codeobj__234;
-static PyObject *__pyx_codeobj__236;
-static PyObject *__pyx_codeobj__238;
-static PyObject *__pyx_codeobj__240;
-static PyObject *__pyx_codeobj__242;
-static PyObject *__pyx_codeobj__244;
-static PyObject *__pyx_codeobj__246;
-static PyObject *__pyx_codeobj__248;
-static PyObject *__pyx_codeobj__250;
-static PyObject *__pyx_codeobj__252;
-static PyObject *__pyx_codeobj__254;
-static PyObject *__pyx_codeobj__256;
-static PyObject *__pyx_codeobj__258;
-static PyObject *__pyx_codeobj__260;
-static PyObject *__pyx_codeobj__262;
-static PyObject *__pyx_codeobj__264;
-static PyObject *__pyx_codeobj__266;
-static PyObject *__pyx_codeobj__268;
-static PyObject *__pyx_codeobj__270;
-static PyObject *__pyx_codeobj__272;
-static PyObject *__pyx_codeobj__274;
-static PyObject *__pyx_codeobj__276;
-static PyObject *__pyx_codeobj__278;
-static PyObject *__pyx_codeobj__280;
-static PyObject *__pyx_codeobj__282;
-static PyObject *__pyx_codeobj__284;
-static PyObject *__pyx_codeobj__286;
-static PyObject *__pyx_codeobj__288;
-static PyObject *__pyx_codeobj__290;
-static PyObject *__pyx_codeobj__292;
-static PyObject *__pyx_codeobj__294;
-static PyObject *__pyx_codeobj__296;
-static PyObject *__pyx_codeobj__298;
-static PyObject *__pyx_codeobj__300;
-static PyObject *__pyx_codeobj__302;
-static PyObject *__pyx_codeobj__304;
-static PyObject *__pyx_codeobj__306;
-static PyObject *__pyx_codeobj__308;
-static PyObject *__pyx_codeobj__310;
-static PyObject *__pyx_codeobj__312;
-static PyObject *__pyx_codeobj__314;
-static PyObject *__pyx_codeobj__316;
-static PyObject *__pyx_codeobj__318;
-static PyObject *__pyx_codeobj__320;
-static PyObject *__pyx_codeobj__322;
-static PyObject *__pyx_codeobj__324;
-static PyObject *__pyx_codeobj__326;
-static PyObject *__pyx_codeobj__328;
-static PyObject *__pyx_codeobj__330;
-static PyObject *__pyx_codeobj__332;
-static PyObject *__pyx_codeobj__334;
-static PyObject *__pyx_codeobj__336;
-static PyObject *__pyx_codeobj__338;
-static PyObject *__pyx_codeobj__340;
-static PyObject *__pyx_codeobj__342;
-static PyObject *__pyx_codeobj__344;
-static PyObject *__pyx_codeobj__346;
-static PyObject *__pyx_codeobj__348;
-static PyObject *__pyx_codeobj__350;
-static PyObject *__pyx_codeobj__352;
-static PyObject *__pyx_codeobj__354;
-static PyObject *__pyx_codeobj__356;
-static PyObject *__pyx_codeobj__358;
-static PyObject *__pyx_codeobj__360;
-static PyObject *__pyx_codeobj__362;
-static PyObject *__pyx_codeobj__364;
-static PyObject *__pyx_codeobj__366;
-static PyObject *__pyx_codeobj__368;
-static PyObject *__pyx_codeobj__371;
-static PyObject *__pyx_codeobj__373;
-static PyObject *__pyx_codeobj__375;
-static PyObject *__pyx_codeobj__377;
-static PyObject *__pyx_codeobj__379;
-static PyObject *__pyx_codeobj__381;
-static PyObject *__pyx_codeobj__383;
-static PyObject *__pyx_codeobj__385;
-static PyObject *__pyx_codeobj__387;
-static PyObject *__pyx_codeobj__389;
-static PyObject *__pyx_codeobj__391;
-static PyObject *__pyx_codeobj__394;
-static PyObject *__pyx_codeobj__396;
-static PyObject *__pyx_codeobj__398;
-static PyObject *__pyx_codeobj__400;
-static PyObject *__pyx_codeobj__402;
-static PyObject *__pyx_codeobj__405;
-static PyObject *__pyx_codeobj__407;
-static PyObject *__pyx_codeobj__409;
-static PyObject *__pyx_codeobj__411;
-static PyObject *__pyx_codeobj__413;
-static PyObject *__pyx_codeobj__415;
-static PyObject *__pyx_codeobj__417;
-static PyObject *__pyx_codeobj__419;
-static PyObject *__pyx_codeobj__421;
-static PyObject *__pyx_codeobj__423;
-static PyObject *__pyx_codeobj__425;
-static PyObject *__pyx_codeobj__427;
-static PyObject *__pyx_codeobj__429;
-static PyObject *__pyx_codeobj__431;
-static PyObject *__pyx_codeobj__433;
-static PyObject *__pyx_codeobj__435;
-static PyObject *__pyx_codeobj__437;
-static PyObject *__pyx_codeobj__439;
-static PyObject *__pyx_codeobj__441;
-static PyObject *__pyx_codeobj__443;
-static PyObject *__pyx_codeobj__445;
-static PyObject *__pyx_codeobj__447;
-static PyObject *__pyx_codeobj__449;
-static PyObject *__pyx_codeobj__451;
-static PyObject *__pyx_codeobj__453;
-static PyObject *__pyx_codeobj__455;
-static PyObject *__pyx_codeobj__457;
-static PyObject *__pyx_codeobj__459;
-static PyObject *__pyx_codeobj__461;
-static PyObject *__pyx_codeobj__463;
-static PyObject *__pyx_codeobj__465;
-static PyObject *__pyx_codeobj__467;
-static PyObject *__pyx_codeobj__469;
-static PyObject *__pyx_codeobj__471;
-static PyObject *__pyx_codeobj__473;
-static PyObject *__pyx_codeobj__475;
-static PyObject *__pyx_codeobj__477;
-static PyObject *__pyx_codeobj__479;
-static PyObject *__pyx_codeobj__481;
-static PyObject *__pyx_codeobj__483;
-static PyObject *__pyx_codeobj__485;
-static PyObject *__pyx_codeobj__487;
-static PyObject *__pyx_codeobj__489;
-static PyObject *__pyx_codeobj__491;
-static PyObject *__pyx_codeobj__493;
-static PyObject *__pyx_codeobj__495;
-static PyObject *__pyx_codeobj__497;
-static PyObject *__pyx_codeobj__499;
-static PyObject *__pyx_codeobj__501;
-static PyObject *__pyx_codeobj__503;
-static PyObject *__pyx_codeobj__505;
-static PyObject *__pyx_codeobj__507;
-static PyObject *__pyx_codeobj__509;
-static PyObject *__pyx_codeobj__511;
-static PyObject *__pyx_codeobj__513;
-static PyObject *__pyx_codeobj__515;
-static PyObject *__pyx_codeobj__517;
-static PyObject *__pyx_codeobj__519;
-static PyObject *__pyx_codeobj__521;
-static PyObject *__pyx_codeobj__523;
-static PyObject *__pyx_codeobj__525;
-static PyObject *__pyx_codeobj__527;
-static PyObject *__pyx_codeobj__529;
-static PyObject *__pyx_codeobj__531;
-static PyObject *__pyx_codeobj__533;
-static PyObject *__pyx_codeobj__535;
-static PyObject *__pyx_codeobj__537;
-static PyObject *__pyx_codeobj__539;
-static PyObject *__pyx_codeobj__541;
-static PyObject *__pyx_codeobj__543;
-static PyObject *__pyx_codeobj__545;
-static PyObject *__pyx_codeobj__547;
-static PyObject *__pyx_codeobj__549;
-static PyObject *__pyx_codeobj__551;
-static PyObject *__pyx_codeobj__553;
-static PyObject *__pyx_codeobj__555;
-static PyObject *__pyx_codeobj__557;
-static PyObject *__pyx_codeobj__559;
-static PyObject *__pyx_codeobj__561;
-static PyObject *__pyx_codeobj__563;
-static PyObject *__pyx_codeobj__565;
-static PyObject *__pyx_codeobj__567;
-static PyObject *__pyx_codeobj__569;
-static PyObject *__pyx_codeobj__571;
-static PyObject *__pyx_codeobj__573;
-static PyObject *__pyx_codeobj__575;
-static PyObject *__pyx_codeobj__577;
-static PyObject *__pyx_codeobj__579;
-static PyObject *__pyx_codeobj__581;
-static PyObject *__pyx_codeobj__583;
-static PyObject *__pyx_codeobj__585;
-static PyObject *__pyx_codeobj__587;
-static PyObject *__pyx_codeobj__589;
-static PyObject *__pyx_codeobj__591;
-static PyObject *__pyx_codeobj__593;
-static PyObject *__pyx_codeobj__595;
-static PyObject *__pyx_codeobj__597;
-static PyObject *__pyx_codeobj__599;
-static PyObject *__pyx_codeobj__601;
-static PyObject *__pyx_codeobj__603;
-static PyObject *__pyx_codeobj__605;
-static PyObject *__pyx_codeobj__607;
-static PyObject *__pyx_codeobj__609;
-static PyObject *__pyx_codeobj__611;
-static PyObject *__pyx_codeobj__613;
-static PyObject *__pyx_codeobj__615;
-static PyObject *__pyx_codeobj__617;
-static PyObject *__pyx_codeobj__619;
-static PyObject *__pyx_codeobj__621;
-static PyObject *__pyx_codeobj__623;
-static PyObject *__pyx_codeobj__625;
-static PyObject *__pyx_codeobj__627;
-static PyObject *__pyx_codeobj__629;
-static PyObject *__pyx_codeobj__631;
-static PyObject *__pyx_codeobj__633;
-static PyObject *__pyx_codeobj__635;
-static PyObject *__pyx_codeobj__637;
-static PyObject *__pyx_codeobj__639;
-static PyObject *__pyx_codeobj__641;
-static PyObject *__pyx_codeobj__643;
-static PyObject *__pyx_codeobj__645;
-static PyObject *__pyx_codeobj__647;
-static PyObject *__pyx_codeobj__649;
-static PyObject *__pyx_codeobj__651;
-static PyObject *__pyx_codeobj__653;
-static PyObject *__pyx_codeobj__655;
-static PyObject *__pyx_codeobj__657;
-static PyObject *__pyx_codeobj__659;
-static PyObject *__pyx_codeobj__661;
-static PyObject *__pyx_codeobj__663;
-static PyObject *__pyx_codeobj__665;
-static PyObject *__pyx_codeobj__667;
-static PyObject *__pyx_codeobj__669;
-static PyObject *__pyx_codeobj__671;
-static PyObject *__pyx_codeobj__673;
-static PyObject *__pyx_codeobj__675;
-static PyObject *__pyx_codeobj__677;
-static PyObject *__pyx_codeobj__679;
-static PyObject *__pyx_codeobj__681;
-static PyObject *__pyx_codeobj__683;
-static PyObject *__pyx_codeobj__685;
-static PyObject *__pyx_codeobj__687;
-static PyObject *__pyx_codeobj__689;
-static PyObject *__pyx_codeobj__691;
-static PyObject *__pyx_codeobj__693;
-static PyObject *__pyx_codeobj__695;
-static PyObject *__pyx_codeobj__697;
-static PyObject *__pyx_codeobj__699;
-static PyObject *__pyx_codeobj__701;
-static PyObject *__pyx_codeobj__703;
-static PyObject *__pyx_codeobj__705;
-static PyObject *__pyx_codeobj__707;
-static PyObject *__pyx_codeobj__709;
-static PyObject *__pyx_codeobj__711;
-static PyObject *__pyx_codeobj__713;
-static PyObject *__pyx_codeobj__715;
-static PyObject *__pyx_codeobj__717;
-static PyObject *__pyx_codeobj__719;
-static PyObject *__pyx_codeobj__721;
-static PyObject *__pyx_codeobj__723;
-static PyObject *__pyx_codeobj__725;
-static PyObject *__pyx_codeobj__727;
-static PyObject *__pyx_codeobj__729;
-static PyObject *__pyx_codeobj__731;
-static PyObject *__pyx_codeobj__733;
-static PyObject *__pyx_codeobj__735;
-static PyObject *__pyx_codeobj__737;
-static PyObject *__pyx_codeobj__739;
-static PyObject *__pyx_codeobj__741;
-static PyObject *__pyx_codeobj__743;
-static PyObject *__pyx_codeobj__745;
-static PyObject *__pyx_codeobj__747;
-static PyObject *__pyx_codeobj__749;
-static PyObject *__pyx_codeobj__751;
-/* Late includes */
-
-
-static PyObject *__pyx_pw_5talib_7_ta_lib_1_ta_check_success(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static PyObject *__pyx_f_5talib_7_ta_lib__ta_check_success(PyObject *__pyx_v_function_name, TA_RetCode __pyx_v_ret_code, CYTHON_UNUSED int __pyx_skip_dispatch) {
-  PyObject *__pyx_v_description = NULL;
-  PyObject *__pyx_r = NULL;
-  __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
-  PyObject *__pyx_t_2 = NULL;
-  __Pyx_RefNannySetupContext("_ta_check_success", 0);
+static PyObject *__pyx_pf_5talib_7_ta_lib_348_ta_getGroupTable(CYTHON_UNUSED PyObject *__pyx_self); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_350_ta_getFuncTable(CYTHON_UNUSED PyObject *__pyx_self, char *__pyx_v_group); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_352__get_flags(CYTHON_UNUSED PyObject *__pyx_self, int __pyx_v_flag, PyObject *__pyx_v_flags_lookup_dict); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_354_ta_getFuncInfo(CYTHON_UNUSED PyObject *__pyx_self, char *__pyx_v_function_name); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_356_ta_getInputParameterInfo(CYTHON_UNUSED PyObject *__pyx_self, char *__pyx_v_function_name, int __pyx_v_idx); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_358_ta_getOptInputParameterInfo(CYTHON_UNUSED PyObject *__pyx_self, char *__pyx_v_function_name, int __pyx_v_idx); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_360_ta_getOutputParameterInfo(CYTHON_UNUSED PyObject *__pyx_self, char *__pyx_v_function_name, int __pyx_v_idx); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_362_get_defaults_and_docs(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_func_info); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_364stream_ACCBANDS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_366stream_ACOS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_368stream_AD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, PyArrayObject *__pyx_v_volume); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_370stream_ADD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real0, PyArrayObject *__pyx_v_real1); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_372stream_ADOSC(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, PyArrayObject *__pyx_v_volume, int __pyx_v_fastperiod, int __pyx_v_slowperiod); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_374stream_ADX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_376stream_ADXR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_378stream_APO(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_fastperiod, int __pyx_v_slowperiod, int __pyx_v_matype); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_380stream_AROON(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, int __pyx_v_timeperiod); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_382stream_AROONOSC(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, int __pyx_v_timeperiod); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_384stream_ASIN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_386stream_ATAN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_388stream_ATR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_390stream_AVGPRICE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_392stream_AVGDEV(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_394stream_BBANDS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod, double __pyx_v_nbdevup, double __pyx_v_nbdevdn, int __pyx_v_matype); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_396stream_BETA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real0, PyArrayObject *__pyx_v_real1, int __pyx_v_timeperiod); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_398stream_BOP(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_400stream_CCI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_402stream_CDL2CROWS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_404stream_CDL3BLACKCROWS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_406stream_CDL3INSIDE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_408stream_CDL3LINESTRIKE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_410stream_CDL3OUTSIDE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_412stream_CDL3STARSINSOUTH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_414stream_CDL3WHITESOLDIERS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_416stream_CDLABANDONEDBABY(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_418stream_CDLADVANCEBLOCK(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_420stream_CDLBELTHOLD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_422stream_CDLBREAKAWAY(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_424stream_CDLCLOSINGMARUBOZU(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_426stream_CDLCONCEALBABYSWALL(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_428stream_CDLCOUNTERATTACK(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_430stream_CDLDARKCLOUDCOVER(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_432stream_CDLDOJI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_434stream_CDLDOJISTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_436stream_CDLDRAGONFLYDOJI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_438stream_CDLENGULFING(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_440stream_CDLEVENINGDOJISTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_442stream_CDLEVENINGSTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_444stream_CDLGAPSIDESIDEWHITE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_446stream_CDLGRAVESTONEDOJI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_448stream_CDLHAMMER(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_450stream_CDLHANGINGMAN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_452stream_CDLHARAMI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_454stream_CDLHARAMICROSS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_456stream_CDLHIGHWAVE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_458stream_CDLHIKKAKE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_460stream_CDLHIKKAKEMOD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_462stream_CDLHOMINGPIGEON(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_464stream_CDLIDENTICAL3CROWS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_466stream_CDLINNECK(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_468stream_CDLINVERTEDHAMMER(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_470stream_CDLKICKING(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_472stream_CDLKICKINGBYLENGTH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_474stream_CDLLADDERBOTTOM(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_476stream_CDLLONGLEGGEDDOJI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_478stream_CDLLONGLINE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_480stream_CDLMARUBOZU(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_482stream_CDLMATCHINGLOW(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_484stream_CDLMATHOLD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_486stream_CDLMORNINGDOJISTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_488stream_CDLMORNINGSTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_490stream_CDLONNECK(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_492stream_CDLPIERCING(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_494stream_CDLRICKSHAWMAN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_496stream_CDLRISEFALL3METHODS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_498stream_CDLSEPARATINGLINES(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_500stream_CDLSHOOTINGSTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_502stream_CDLSHORTLINE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_504stream_CDLSPINNINGTOP(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_506stream_CDLSTALLEDPATTERN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_508stream_CDLSTICKSANDWICH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_510stream_CDLTAKURI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_512stream_CDLTASUKIGAP(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_514stream_CDLTHRUSTING(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_516stream_CDLTRISTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_518stream_CDLUNIQUE3RIVER(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_520stream_CDLUPSIDEGAP2CROWS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_522stream_CDLXSIDEGAP3METHODS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_524stream_CEIL(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_526stream_CMO(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_528stream_CORREL(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real0, PyArrayObject *__pyx_v_real1, int __pyx_v_timeperiod); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_530stream_COS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_532stream_COSH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_534stream_DEMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_536stream_DIV(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real0, PyArrayObject *__pyx_v_real1); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_538stream_DX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_540stream_EMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_542stream_EXP(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_544stream_FLOOR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_546stream_HT_DCPERIOD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_548stream_HT_DCPHASE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_550stream_HT_PHASOR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_552stream_HT_SINE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_554stream_HT_TRENDLINE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_556stream_HT_TRENDMODE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_558stream_IMI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_560stream_KAMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_562stream_LINEARREG(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_564stream_LINEARREG_ANGLE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_566stream_LINEARREG_INTERCEPT(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_568stream_LINEARREG_SLOPE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_570stream_LN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_572stream_LOG10(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_574stream_MA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod, int __pyx_v_matype); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_576stream_MACD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_fastperiod, int __pyx_v_slowperiod, int __pyx_v_signalperiod); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_578stream_MACDEXT(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_fastperiod, int __pyx_v_fastmatype, int __pyx_v_slowperiod, int __pyx_v_slowmatype, int __pyx_v_signalperiod, int __pyx_v_signalmatype); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_580stream_MACDFIX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_signalperiod); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_582stream_MAMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, double __pyx_v_fastlimit, double __pyx_v_slowlimit); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_584stream_MAVP(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, PyArrayObject *__pyx_v_periods, int __pyx_v_minperiod, int __pyx_v_maxperiod, int __pyx_v_matype); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_586stream_MAX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_588stream_MAXINDEX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_590stream_MEDPRICE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_592stream_MFI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, PyArrayObject *__pyx_v_volume, int __pyx_v_timeperiod); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_594stream_MIDPOINT(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_596stream_MIDPRICE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, int __pyx_v_timeperiod); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_598stream_MIN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_600stream_MININDEX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_602stream_MINMAX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_604stream_MINMAXINDEX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_606stream_MINUS_DI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_608stream_MINUS_DM(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, int __pyx_v_timeperiod); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_610stream_MOM(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_612stream_MULT(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real0, PyArrayObject *__pyx_v_real1); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_614stream_NATR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_616stream_OBV(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, PyArrayObject *__pyx_v_volume); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_618stream_PLUS_DI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_620stream_PLUS_DM(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, int __pyx_v_timeperiod); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_622stream_PPO(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_fastperiod, int __pyx_v_slowperiod, int __pyx_v_matype); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_624stream_ROC(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_626stream_ROCP(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_628stream_ROCR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_630stream_ROCR100(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_632stream_RSI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_634stream_SAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, double __pyx_v_acceleration, double __pyx_v_maximum); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_636stream_SAREXT(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, double __pyx_v_startvalue, double __pyx_v_offsetonreverse, double __pyx_v_accelerationinitlong, double __pyx_v_accelerationlong, double __pyx_v_accelerationmaxlong, double __pyx_v_accelerationinitshort, double __pyx_v_accelerationshort, double __pyx_v_accelerationmaxshort); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_638stream_SIN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_640stream_SINH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_642stream_SMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_644stream_SQRT(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_646stream_STDDEV(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod, double __pyx_v_nbdev); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_648stream_STOCH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_fastk_period, int __pyx_v_slowk_period, int __pyx_v_slowk_matype, int __pyx_v_slowd_period, int __pyx_v_slowd_matype); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_650stream_STOCHF(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_fastk_period, int __pyx_v_fastd_period, int __pyx_v_fastd_matype); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_652stream_STOCHRSI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod, int __pyx_v_fastk_period, int __pyx_v_fastd_period, int __pyx_v_fastd_matype); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_654stream_SUB(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real0, PyArrayObject *__pyx_v_real1); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_656stream_SUM(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_658stream_T3(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod, double __pyx_v_vfactor); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_660stream_TAN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_662stream_TANH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_664stream_TEMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_666stream_TRANGE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_668stream_TRIMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_670stream_TRIX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_672stream_TSF(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_674stream_TYPPRICE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_676stream_ULTOSC(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod1, int __pyx_v_timeperiod2, int __pyx_v_timeperiod3); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_678stream_VAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod, double __pyx_v_nbdev); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_680stream_WCLPRICE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_682stream_WILLR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod); /* proto */
+static PyObject *__pyx_pf_5talib_7_ta_lib_684stream_WMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod); /* proto */
+/* #### Code section: late_includes ### */
+/* #### Code section: module_state ### */
+/* SmallCodeConfig */
+#ifndef CYTHON_SMALL_CODE
+#if defined(__clang__)
+    #define CYTHON_SMALL_CODE
+#elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3))
+    #define CYTHON_SMALL_CODE __attribute__((cold))
+#else
+    #define CYTHON_SMALL_CODE
+#endif
+#endif
 
-  switch (__pyx_v_ret_code) {
-    case 0:
+typedef struct {
+  PyObject *__pyx_d;
+  PyObject *__pyx_b;
+  PyObject *__pyx_cython_runtime;
+  PyObject *__pyx_empty_tuple;
+  PyObject *__pyx_empty_bytes;
+  PyObject *__pyx_empty_unicode;
+  #ifdef __Pyx_CyFunction_USED
+  PyTypeObject *__pyx_CyFunctionType;
+  #endif
+  #ifdef __Pyx_FusedFunction_USED
+  PyTypeObject *__pyx_FusedFunctionType;
+  #endif
+  #ifdef __Pyx_Generator_USED
+  PyTypeObject *__pyx_GeneratorType;
+  #endif
+  #ifdef __Pyx_IterableCoroutine_USED
+  PyTypeObject *__pyx_IterableCoroutineType;
+  #endif
+  #ifdef __Pyx_Coroutine_USED
+  PyTypeObject *__pyx_CoroutineAwaitType;
+  #endif
+  #ifdef __Pyx_Coroutine_USED
+  PyTypeObject *__pyx_CoroutineType;
+  #endif
+  PyTypeObject *__pyx_ptype_7cpython_4type_type;
+  PyTypeObject *__pyx_ptype_5numpy_dtype;
+  PyTypeObject *__pyx_ptype_5numpy_flatiter;
+  PyTypeObject *__pyx_ptype_5numpy_broadcast;
+  PyTypeObject *__pyx_ptype_5numpy_ndarray;
+  PyTypeObject *__pyx_ptype_5numpy_generic;
+  PyTypeObject *__pyx_ptype_5numpy_number;
+  PyTypeObject *__pyx_ptype_5numpy_integer;
+  PyTypeObject *__pyx_ptype_5numpy_signedinteger;
+  PyTypeObject *__pyx_ptype_5numpy_unsignedinteger;
+  PyTypeObject *__pyx_ptype_5numpy_inexact;
+  PyTypeObject *__pyx_ptype_5numpy_floating;
+  PyTypeObject *__pyx_ptype_5numpy_complexfloating;
+  PyTypeObject *__pyx_ptype_5numpy_flexible;
+  PyTypeObject *__pyx_ptype_5numpy_character;
+  PyTypeObject *__pyx_ptype_5numpy_ufunc;
+  __Pyx_CachedCFunction __pyx_umethod_PyDict_Type_keys;
+  __Pyx_CachedCFunction __pyx_umethod_PyDict_Type_pop;
+  PyObject *__pyx_tuple[10];
+  PyObject *__pyx_codeobj_tab[369];
+  PyObject *__pyx_string_tab[945];
+  PyObject *__pyx_int_0;
+  PyObject *__pyx_int_1;
+  PyObject *__pyx_int_2;
+  PyObject *__pyx_int_3;
+  PyObject *__pyx_int_4;
+  PyObject *__pyx_int_8;
+  PyObject *__pyx_int_9;
+  PyObject *__pyx_int_12;
+  PyObject *__pyx_int_16;
+  PyObject *__pyx_int_32;
+  PyObject *__pyx_int_64;
+  PyObject *__pyx_int_128;
+  PyObject *__pyx_int_256;
+  PyObject *__pyx_int_512;
+  PyObject *__pyx_int_1024;
+  PyObject *__pyx_int_2048;
+  PyObject *__pyx_int_4096;
+  PyObject *__pyx_int_16777216;
+  PyObject *__pyx_int_67108864;
+  PyObject *__pyx_int_134217728;
+  PyObject *__pyx_int_268435456;
+  PyObject *__pyx_int_neg_1;
+/* #### Code section: module_state_contents ### */
+/* CommonTypesMetaclass.module_state_decls */
+PyTypeObject *__pyx_CommonTypesMetaclassType;
+
+/* CachedMethodType.module_state_decls */
+#if CYTHON_COMPILING_IN_LIMITED_API
+PyObject *__Pyx_CachedMethodType;
+#endif
 
-    __Pyx_XDECREF(__pyx_r);
-    __Pyx_INCREF(Py_True);
-    __pyx_r = Py_True;
-    goto __pyx_L0;
+/* CodeObjectCache.module_state_decls */
+struct __Pyx_CodeObjectCache __pyx_code_cache;
 
-    break;
-    case 1:
+/* #### Code section: module_state_end ### */
+} __pyx_mstatetype;
 
-    __Pyx_INCREF(__pyx_kp_s_Library_Not_Initialized_TA_LIB_N);
-    __pyx_v_description = __pyx_kp_s_Library_Not_Initialized_TA_LIB_N;
+#if CYTHON_USE_MODULE_STATE
+#ifdef __cplusplus
+namespace {
+extern struct PyModuleDef __pyx_moduledef;
+} /* anonymous namespace */
+#else
+static struct PyModuleDef __pyx_moduledef;
+#endif
 
-    break;
-    case 2:
+#define __pyx_mstate_global (__Pyx_PyModule_GetState(__Pyx_State_FindModule(&__pyx_moduledef)))
 
-    __Pyx_INCREF(__pyx_kp_s_Bad_Parameter_TA_BAD_PARAM);
-    __pyx_v_description = __pyx_kp_s_Bad_Parameter_TA_BAD_PARAM;
+#define __pyx_m (__Pyx_State_FindModule(&__pyx_moduledef))
+#else
+static __pyx_mstatetype __pyx_mstate_global_static =
+#ifdef __cplusplus
+    {};
+#else
+    {0};
+#endif
+static __pyx_mstatetype * const __pyx_mstate_global = &__pyx_mstate_global_static;
+#endif
+/* #### Code section: constant_name_defines ### */
+#define __pyx_kp_u_ __pyx_string_tab[0]
+#define __pyx_kp_u_3 __pyx_string_tab[1]
+#define __pyx_n_u_ACCBANDS __pyx_string_tab[2]
+#define __pyx_n_u_ACOS __pyx_string_tab[3]
+#define __pyx_n_u_AD __pyx_string_tab[4]
+#define __pyx_n_u_ADD __pyx_string_tab[5]
+#define __pyx_n_u_ADOSC __pyx_string_tab[6]
+#define __pyx_n_u_ADX __pyx_string_tab[7]
+#define __pyx_n_u_ADXR __pyx_string_tab[8]
+#define __pyx_n_u_ALL __pyx_string_tab[9]
+#define __pyx_n_u_APO __pyx_string_tab[10]
+#define __pyx_n_u_AROON __pyx_string_tab[11]
+#define __pyx_n_u_AROONOSC __pyx_string_tab[12]
+#define __pyx_n_u_ARRAY_TYPES __pyx_string_tab[13]
+#define __pyx_n_u_ASIN __pyx_string_tab[14]
+#define __pyx_n_u_ATAN __pyx_string_tab[15]
+#define __pyx_n_u_ATR __pyx_string_tab[16]
+#define __pyx_n_u_AVGDEV __pyx_string_tab[17]
+#define __pyx_n_u_AVGPRICE __pyx_string_tab[18]
+#define __pyx_n_u_AllCandleSettings __pyx_string_tab[19]
+#define __pyx_kp_u_Allocation_Error_TA_ALLOC_ERR __pyx_string_tab[20]
+#define __pyx_n_u_BBANDS __pyx_string_tab[21]
+#define __pyx_n_u_BETA __pyx_string_tab[22]
+#define __pyx_n_u_BOP __pyx_string_tab[23]
+#define __pyx_kp_u_Bad_Object_TA_BAD_OBJECT __pyx_string_tab[24]
+#define __pyx_kp_u_Bad_Parameter_TA_BAD_PARAM __pyx_string_tab[25]
+#define __pyx_n_u_BodyDoji __pyx_string_tab[26]
+#define __pyx_n_u_BodyLong __pyx_string_tab[27]
+#define __pyx_n_u_BodyShort __pyx_string_tab[28]
+#define __pyx_n_u_BodyVeryLong __pyx_string_tab[29]
+#define __pyx_kp_u_Bull_Bear_Pattern_Bearish_0_Neut __pyx_string_tab[30]
+#define __pyx_n_u_CCI __pyx_string_tab[31]
+#define __pyx_n_u_CDL2CROWS __pyx_string_tab[32]
+#define __pyx_n_u_CDL3BLACKCROWS __pyx_string_tab[33]
+#define __pyx_n_u_CDL3INSIDE __pyx_string_tab[34]
+#define __pyx_n_u_CDL3LINESTRIKE __pyx_string_tab[35]
+#define __pyx_n_u_CDL3OUTSIDE __pyx_string_tab[36]
+#define __pyx_n_u_CDL3STARSINSOUTH __pyx_string_tab[37]
+#define __pyx_n_u_CDL3WHITESOLDIERS __pyx_string_tab[38]
+#define __pyx_n_u_CDLABANDONEDBABY __pyx_string_tab[39]
+#define __pyx_n_u_CDLADVANCEBLOCK __pyx_string_tab[40]
+#define __pyx_n_u_CDLBELTHOLD __pyx_string_tab[41]
+#define __pyx_n_u_CDLBREAKAWAY __pyx_string_tab[42]
+#define __pyx_n_u_CDLCLOSINGMARUBOZU __pyx_string_tab[43]
+#define __pyx_n_u_CDLCONCEALBABYSWALL __pyx_string_tab[44]
+#define __pyx_n_u_CDLCOUNTERATTACK __pyx_string_tab[45]
+#define __pyx_n_u_CDLDARKCLOUDCOVER __pyx_string_tab[46]
+#define __pyx_n_u_CDLDOJI __pyx_string_tab[47]
+#define __pyx_n_u_CDLDOJISTAR __pyx_string_tab[48]
+#define __pyx_n_u_CDLDRAGONFLYDOJI __pyx_string_tab[49]
+#define __pyx_n_u_CDLENGULFING __pyx_string_tab[50]
+#define __pyx_n_u_CDLEVENINGDOJISTAR __pyx_string_tab[51]
+#define __pyx_n_u_CDLEVENINGSTAR __pyx_string_tab[52]
+#define __pyx_n_u_CDLGAPSIDESIDEWHITE __pyx_string_tab[53]
+#define __pyx_n_u_CDLGRAVESTONEDOJI __pyx_string_tab[54]
+#define __pyx_n_u_CDLHAMMER __pyx_string_tab[55]
+#define __pyx_n_u_CDLHANGINGMAN __pyx_string_tab[56]
+#define __pyx_n_u_CDLHARAMI __pyx_string_tab[57]
+#define __pyx_n_u_CDLHARAMICROSS __pyx_string_tab[58]
+#define __pyx_n_u_CDLHIGHWAVE __pyx_string_tab[59]
+#define __pyx_n_u_CDLHIKKAKE __pyx_string_tab[60]
+#define __pyx_n_u_CDLHIKKAKEMOD __pyx_string_tab[61]
+#define __pyx_n_u_CDLHOMINGPIGEON __pyx_string_tab[62]
+#define __pyx_n_u_CDLIDENTICAL3CROWS __pyx_string_tab[63]
+#define __pyx_n_u_CDLINNECK __pyx_string_tab[64]
+#define __pyx_n_u_CDLINVERTEDHAMMER __pyx_string_tab[65]
+#define __pyx_n_u_CDLKICKING __pyx_string_tab[66]
+#define __pyx_n_u_CDLKICKINGBYLENGTH __pyx_string_tab[67]
+#define __pyx_n_u_CDLLADDERBOTTOM __pyx_string_tab[68]
+#define __pyx_n_u_CDLLONGLEGGEDDOJI __pyx_string_tab[69]
+#define __pyx_n_u_CDLLONGLINE __pyx_string_tab[70]
+#define __pyx_n_u_CDLMARUBOZU __pyx_string_tab[71]
+#define __pyx_n_u_CDLMATCHINGLOW __pyx_string_tab[72]
+#define __pyx_n_u_CDLMATHOLD __pyx_string_tab[73]
+#define __pyx_n_u_CDLMORNINGDOJISTAR __pyx_string_tab[74]
+#define __pyx_n_u_CDLMORNINGSTAR __pyx_string_tab[75]
+#define __pyx_n_u_CDLONNECK __pyx_string_tab[76]
+#define __pyx_n_u_CDLPIERCING __pyx_string_tab[77]
+#define __pyx_n_u_CDLRICKSHAWMAN __pyx_string_tab[78]
+#define __pyx_n_u_CDLRISEFALL3METHODS __pyx_string_tab[79]
+#define __pyx_n_u_CDLSEPARATINGLINES __pyx_string_tab[80]
+#define __pyx_n_u_CDLSHOOTINGSTAR __pyx_string_tab[81]
+#define __pyx_n_u_CDLSHORTLINE __pyx_string_tab[82]
+#define __pyx_n_u_CDLSPINNINGTOP __pyx_string_tab[83]
+#define __pyx_n_u_CDLSTALLEDPATTERN __pyx_string_tab[84]
+#define __pyx_n_u_CDLSTICKSANDWICH __pyx_string_tab[85]
+#define __pyx_n_u_CDLTAKURI __pyx_string_tab[86]
+#define __pyx_n_u_CDLTASUKIGAP __pyx_string_tab[87]
+#define __pyx_n_u_CDLTHRUSTING __pyx_string_tab[88]
+#define __pyx_n_u_CDLTRISTAR __pyx_string_tab[89]
+#define __pyx_n_u_CDLUNIQUE3RIVER __pyx_string_tab[90]
+#define __pyx_n_u_CDLUPSIDEGAP2CROWS __pyx_string_tab[91]
+#define __pyx_n_u_CDLXSIDEGAP3METHODS __pyx_string_tab[92]
+#define __pyx_n_u_CEIL __pyx_string_tab[93]
+#define __pyx_n_u_CMO __pyx_string_tab[94]
+#define __pyx_n_u_CORREL __pyx_string_tab[95]
+#define __pyx_n_u_COS __pyx_string_tab[96]
+#define __pyx_n_u_COSH __pyx_string_tab[97]
+#define __pyx_n_u_CandleSettingType __pyx_string_tab[98]
+#define __pyx_n_u_DEMA __pyx_string_tab[99]
+#define __pyx_n_u_DIV __pyx_string_tab[100]
+#define __pyx_n_u_DX __pyx_string_tab[101]
+#define __pyx_kp_u_Dashed_Line __pyx_string_tab[102]
+#define __pyx_n_u_DataFrame __pyx_string_tab[103]
+#define __pyx_n_u_Dot __pyx_string_tab[104]
+#define __pyx_kp_u_Dotted_Line __pyx_string_tab[105]
+#define __pyx_kp_u_Double_Exponential_Moving_Averag __pyx_string_tab[106]
+#define __pyx_n_u_EMA __pyx_string_tab[107]
+#define __pyx_n_u_EXP __pyx_string_tab[108]
+#define __pyx_n_u_Equal __pyx_string_tab[109]
+#define __pyx_kp_u_Exponential_Moving_Average __pyx_string_tab[110]
+#define __pyx_n_u_FLOOR __pyx_string_tab[111]
+#define __pyx_n_u_Far __pyx_string_tab[112]
+#define __pyx_n_u_Function __pyx_string_tab[113]
+#define __pyx_kp_u_Function_Not_Found_TA_FUNC_NOT_F __pyx_string_tab[114]
+#define __pyx_n_u_Function___call __pyx_string_tab[115]
+#define __pyx_n_u_Function___call_function __pyx_string_tab[116]
+#define __pyx_n_u_Function___check_opt_input_value __pyx_string_tab[117]
+#define __pyx_n_u_Function___get_opt_input_value __pyx_string_tab[118]
+#define __pyx_n_u_Function___init __pyx_string_tab[119]
+#define __pyx_n_u_Function___input_price_series_na __pyx_string_tab[120]
+#define __pyx_n_u_Function___local __pyx_string_tab[121]
+#define __pyx_n_u_Function___repr __pyx_string_tab[122]
+#define __pyx_n_u_Function___str __pyx_string_tab[123]
+#define __pyx_n_u_Function___unicode __pyx_string_tab[124]
+#define __pyx_n_u_Function__call_function __pyx_string_tab[125]
+#define __pyx_n_u_Function__check_opt_input_value __pyx_string_tab[126]
+#define __pyx_n_u_Function__get_opt_input_value __pyx_string_tab[127]
+#define __pyx_n_u_Function__input_price_series_na __pyx_string_tab[128]
+#define __pyx_n_u_Function__local __pyx_string_tab[129]
+#define __pyx_n_u_Function__localdata __pyx_string_tab[130]
+#define __pyx_n_u_Function__name __pyx_string_tab[131]
+#define __pyx_n_u_Function__namestr __pyx_string_tab[132]
+#define __pyx_n_u_Function_function_flags __pyx_string_tab[133]
+#define __pyx_n_u_Function_get_input_arrays __pyx_string_tab[134]
+#define __pyx_n_u_Function_get_input_names __pyx_string_tab[135]
+#define __pyx_n_u_Function_get_parameters __pyx_string_tab[136]
+#define __pyx_kp_u_Function_has_an_unstable_period __pyx_string_tab[137]
+#define __pyx_n_u_Function_info __pyx_string_tab[138]
+#define __pyx_n_u_Function_lookback __pyx_string_tab[139]
+#define __pyx_n_u_Function_output_flags __pyx_string_tab[140]
+#define __pyx_n_u_Function_output_names __pyx_string_tab[141]
+#define __pyx_n_u_Function_outputs __pyx_string_tab[142]
+#define __pyx_n_u_Function_run __pyx_string_tab[143]
+#define __pyx_n_u_Function_set_function_args __pyx_string_tab[144]
+#define __pyx_n_u_Function_set_input_arrays __pyx_string_tab[145]
+#define __pyx_n_u_Function_set_input_names __pyx_string_tab[146]
+#define __pyx_n_u_Function_set_parameters __pyx_string_tab[147]
+#define __pyx_kp_u_Group_Not_Found_TA_GROUP_NOT_FOU __pyx_string_tab[148]
+#define __pyx_n_u_HT_DCPERIOD __pyx_string_tab[149]
+#define __pyx_n_u_HT_DCPHASE __pyx_string_tab[150]
+#define __pyx_n_u_HT_PHASOR __pyx_string_tab[151]
+#define __pyx_n_u_HT_SINE __pyx_string_tab[152]
+#define __pyx_n_u_HT_TRENDLINE __pyx_string_tab[153]
+#define __pyx_n_u_HT_TRENDMODE __pyx_string_tab[154]
+#define __pyx_n_u_HighLow __pyx_string_tab[155]
+#define __pyx_n_u_Histogram __pyx_string_tab[156]
+#define __pyx_n_u_IMI __pyx_string_tab[157]
+#define __pyx_n_u_INPUT_ARRAYS_TYPES __pyx_string_tab[158]
+#define __pyx_n_u_INPUT_PRICE_SERIES_DEFAULTS __pyx_string_tab[159]
+#define __pyx_n_u_ImportError __pyx_string_tab[160]
+#define __pyx_n_u_IndexError __pyx_string_tab[161]
+#define __pyx_kp_u_Input_Not_All_Initialized_TA_INP __pyx_string_tab[162]
+#define __pyx_kp_u_Inputs __pyx_string_tab[163]
+#define __pyx_kp_u_Internal_Error_TA_INTERNAL_ERROR __pyx_string_tab[164]
+#define __pyx_kp_u_Invalid_Handle_TA_INVALID_HANDLE __pyx_string_tab[165]
+#define __pyx_kp_u_Invalid_List_Type_TA_INVALID_LIS __pyx_string_tab[166]
+#define __pyx_kp_u_Invalid_Parameter_Function_TA_IN __pyx_string_tab[167]
+#define __pyx_kp_u_Invalid_Parameter_Holder_TA_INVA __pyx_string_tab[168]
+#define __pyx_kp_u_Invalid_Parameter_Holder_Type_TA __pyx_string_tab[169]
+#define __pyx_kp_u_Invalid_parameter_value_for __pyx_string_tab[170]
+#define __pyx_n_u_KAMA __pyx_string_tab[171]
+#define __pyx_kp_u_Kaufman_Adaptive_Moving_Average __pyx_string_tab[172]
+#define __pyx_n_u_LINEARREG __pyx_string_tab[173]
+#define __pyx_n_u_LINEARREG_ANGLE __pyx_string_tab[174]
+#define __pyx_n_u_LINEARREG_INTERCEPT __pyx_string_tab[175]
+#define __pyx_n_u_LINEARREG_SLOPE __pyx_string_tab[176]
+#define __pyx_n_u_LN __pyx_string_tab[177]
+#define __pyx_n_u_LOG10 __pyx_string_tab[178]
+#define __pyx_kp_u_Library_Not_Initialized_TA_LIB_N __pyx_string_tab[179]
+#define __pyx_n_u_Line __pyx_string_tab[180]
+#define __pyx_n_u_MA __pyx_string_tab[181]
+#define __pyx_n_u_MACD __pyx_string_tab[182]
+#define __pyx_n_u_MACDEXT __pyx_string_tab[183]
+#define __pyx_n_u_MACDFIX __pyx_string_tab[184]
+#define __pyx_n_u_MAMA __pyx_string_tab[185]
+#define __pyx_n_u_MAVP __pyx_string_tab[186]
+#define __pyx_n_u_MAX __pyx_string_tab[187]
+#define __pyx_n_u_MAXINDEX __pyx_string_tab[188]
+#define __pyx_n_u_MA_Type __pyx_string_tab[189]
+#define __pyx_n_u_MA_Type___getitem __pyx_string_tab[190]
+#define __pyx_n_u_MA_Type___init __pyx_string_tab[191]
+#define __pyx_n_u_MEDPRICE __pyx_string_tab[192]
+#define __pyx_kp_u_MESA_Adaptive_Moving_Average __pyx_string_tab[193]
+#define __pyx_n_u_MFI __pyx_string_tab[194]
+#define __pyx_n_u_MIDPOINT __pyx_string_tab[195]
+#define __pyx_n_u_MIDPRICE __pyx_string_tab[196]
+#define __pyx_n_u_MIN __pyx_string_tab[197]
+#define __pyx_n_u_MININDEX __pyx_string_tab[198]
+#define __pyx_n_u_MINMAX __pyx_string_tab[199]
+#define __pyx_n_u_MINMAXINDEX __pyx_string_tab[200]
+#define __pyx_n_u_MINUS_DI __pyx_string_tab[201]
+#define __pyx_n_u_MINUS_DM __pyx_string_tab[202]
+#define __pyx_n_u_MOM __pyx_string_tab[203]
+#define __pyx_n_u_MULT __pyx_string_tab[204]
+#define __pyx_n_u_ModuleNotFoundError __pyx_string_tab[205]
+#define __pyx_n_u_NATR __pyx_string_tab[206]
+#define __pyx_n_u_NONE __pyx_string_tab[207]
+#define __pyx_n_u_NameError __pyx_string_tab[208]
+#define __pyx_n_u_Near __pyx_string_tab[209]
+#define __pyx_kp_u_None __pyx_string_tab[210]
+#define __pyx_kp_u_Not_Supported_TA_NOT_SUPPORTED __pyx_string_tab[211]
+#define __pyx_kp_u_Not_enough_price_arguments_expec __pyx_string_tab[212]
+#define __pyx_kp_u_Note_that_Cython_is_deliberately __pyx_string_tab[213]
+#define __pyx_n_u_OBV __pyx_string_tab[214]
+#define __pyx_n_u_OrderedDict __pyx_string_tab[215]
+#define __pyx_kp_u_Out_of_Range_End_Index_TA_OUT_OF __pyx_string_tab[216]
+#define __pyx_kp_u_Out_of_Range_Start_Index_TA_OUT __pyx_string_tab[217]
+#define __pyx_kp_u_Output_Not_All_Initialized_TA_OU __pyx_string_tab[218]
+#define __pyx_kp_u_Output_can_be_negative __pyx_string_tab[219]
+#define __pyx_kp_u_Output_can_be_positive __pyx_string_tab[220]
+#define __pyx_kp_u_Output_can_be_zero __pyx_string_tab[221]
+#define __pyx_kp_u_Output_is_a_candlestick __pyx_string_tab[222]
+#define __pyx_kp_u_Output_is_over_volume __pyx_string_tab[223]
+#define __pyx_kp_u_Output_scale_same_as_input __pyx_string_tab[224]
+#define __pyx_kp_u_Outputs __pyx_string_tab[225]
+#define __pyx_n_u_PANDAS_DATAFRAME __pyx_string_tab[226]
+#define __pyx_n_u_PANDAS_SERIES __pyx_string_tab[227]
+#define __pyx_n_u_PLUS_DI __pyx_string_tab[228]
+#define __pyx_n_u_PLUS_DM __pyx_string_tab[229]
+#define __pyx_n_u_POLARS_DATAFRAME __pyx_string_tab[230]
+#define __pyx_n_u_POLARS_SERIES __pyx_string_tab[231]
+#define __pyx_n_u_PPO __pyx_string_tab[232]
+#define __pyx_kp_u_Parameters __pyx_string_tab[233]
+#define __pyx_kp_u_Pattern_Bool __pyx_string_tab[234]
+#define __pyx_n_u_ROC __pyx_string_tab[235]
+#define __pyx_n_u_ROCP __pyx_string_tab[236]
+#define __pyx_n_u_ROCR __pyx_string_tab[237]
+#define __pyx_n_u_ROCR100 __pyx_string_tab[238]
+#define __pyx_n_u_RSI __pyx_string_tab[239]
+#define __pyx_n_u_RangeType __pyx_string_tab[240]
+#define __pyx_n_u_RealBody __pyx_string_tab[241]
+#define __pyx_n_u_SAR __pyx_string_tab[242]
+#define __pyx_n_u_SAREXT __pyx_string_tab[243]
+#define __pyx_n_u_SIN __pyx_string_tab[244]
+#define __pyx_n_u_SINH __pyx_string_tab[245]
+#define __pyx_n_u_SMA __pyx_string_tab[246]
+#define __pyx_n_u_SQRT __pyx_string_tab[247]
+#define __pyx_n_u_STDDEV __pyx_string_tab[248]
+#define __pyx_n_u_STOCH __pyx_string_tab[249]
+#define __pyx_n_u_STOCHF __pyx_string_tab[250]
+#define __pyx_n_u_STOCHRSI __pyx_string_tab[251]
+#define __pyx_n_u_SUB __pyx_string_tab[252]
+#define __pyx_n_u_SUM __pyx_string_tab[253]
+#define __pyx_n_u_Series __pyx_string_tab[254]
+#define __pyx_n_u_ShadowLong __pyx_string_tab[255]
+#define __pyx_n_u_ShadowShort __pyx_string_tab[256]
+#define __pyx_n_u_ShadowVeryLong __pyx_string_tab[257]
+#define __pyx_n_u_ShadowVeryShort __pyx_string_tab[258]
+#define __pyx_n_u_Shadows __pyx_string_tab[259]
+#define __pyx_kp_u_Simple_Moving_Average __pyx_string_tab[260]
+#define __pyx_kp_u_Strength_Pattern_200_100_Bearish __pyx_string_tab[261]
+#define __pyx_n_u_T3 __pyx_string_tab[262]
+#define __pyx_n_u_TAN __pyx_string_tab[263]
+#define __pyx_n_u_TANH __pyx_string_tab[264]
+#define __pyx_n_u_TA_ACCBANDS __pyx_string_tab[265]
+#define __pyx_n_u_TA_ACOS __pyx_string_tab[266]
+#define __pyx_n_u_TA_AD __pyx_string_tab[267]
+#define __pyx_n_u_TA_ADD __pyx_string_tab[268]
+#define __pyx_n_u_TA_ADOSC __pyx_string_tab[269]
+#define __pyx_n_u_TA_ADX __pyx_string_tab[270]
+#define __pyx_n_u_TA_ADXR __pyx_string_tab[271]
+#define __pyx_n_u_TA_APO __pyx_string_tab[272]
+#define __pyx_n_u_TA_AROON __pyx_string_tab[273]
+#define __pyx_n_u_TA_AROONOSC __pyx_string_tab[274]
+#define __pyx_n_u_TA_ASIN __pyx_string_tab[275]
+#define __pyx_n_u_TA_ATAN __pyx_string_tab[276]
+#define __pyx_n_u_TA_ATR __pyx_string_tab[277]
+#define __pyx_n_u_TA_AVGDEV __pyx_string_tab[278]
+#define __pyx_n_u_TA_AVGPRICE __pyx_string_tab[279]
+#define __pyx_n_u_TA_BBANDS __pyx_string_tab[280]
+#define __pyx_n_u_TA_BETA __pyx_string_tab[281]
+#define __pyx_n_u_TA_BOP __pyx_string_tab[282]
+#define __pyx_n_u_TA_CCI __pyx_string_tab[283]
+#define __pyx_n_u_TA_CDL2CROWS __pyx_string_tab[284]
+#define __pyx_n_u_TA_CDL3BLACKCROWS __pyx_string_tab[285]
+#define __pyx_n_u_TA_CDL3INSIDE __pyx_string_tab[286]
+#define __pyx_n_u_TA_CDL3LINESTRIKE __pyx_string_tab[287]
+#define __pyx_n_u_TA_CDL3OUTSIDE __pyx_string_tab[288]
+#define __pyx_n_u_TA_CDL3STARSINSOUTH __pyx_string_tab[289]
+#define __pyx_n_u_TA_CDL3WHITESOLDIERS __pyx_string_tab[290]
+#define __pyx_n_u_TA_CDLABANDONEDBABY __pyx_string_tab[291]
+#define __pyx_n_u_TA_CDLADVANCEBLOCK __pyx_string_tab[292]
+#define __pyx_n_u_TA_CDLBELTHOLD __pyx_string_tab[293]
+#define __pyx_n_u_TA_CDLBREAKAWAY __pyx_string_tab[294]
+#define __pyx_n_u_TA_CDLCLOSINGMARUBOZU __pyx_string_tab[295]
+#define __pyx_n_u_TA_CDLCONCEALBABYSWALL __pyx_string_tab[296]
+#define __pyx_n_u_TA_CDLCOUNTERATTACK __pyx_string_tab[297]
+#define __pyx_n_u_TA_CDLDARKCLOUDCOVER __pyx_string_tab[298]
+#define __pyx_n_u_TA_CDLDOJI __pyx_string_tab[299]
+#define __pyx_n_u_TA_CDLDOJISTAR __pyx_string_tab[300]
+#define __pyx_n_u_TA_CDLDRAGONFLYDOJI __pyx_string_tab[301]
+#define __pyx_n_u_TA_CDLENGULFING __pyx_string_tab[302]
+#define __pyx_n_u_TA_CDLEVENINGDOJISTAR __pyx_string_tab[303]
+#define __pyx_n_u_TA_CDLEVENINGSTAR __pyx_string_tab[304]
+#define __pyx_n_u_TA_CDLGAPSIDESIDEWHITE __pyx_string_tab[305]
+#define __pyx_n_u_TA_CDLGRAVESTONEDOJI __pyx_string_tab[306]
+#define __pyx_n_u_TA_CDLHAMMER __pyx_string_tab[307]
+#define __pyx_n_u_TA_CDLHANGINGMAN __pyx_string_tab[308]
+#define __pyx_n_u_TA_CDLHARAMI __pyx_string_tab[309]
+#define __pyx_n_u_TA_CDLHARAMICROSS __pyx_string_tab[310]
+#define __pyx_n_u_TA_CDLHIGHWAVE __pyx_string_tab[311]
+#define __pyx_n_u_TA_CDLHIKKAKE __pyx_string_tab[312]
+#define __pyx_n_u_TA_CDLHIKKAKEMOD __pyx_string_tab[313]
+#define __pyx_n_u_TA_CDLHOMINGPIGEON __pyx_string_tab[314]
+#define __pyx_n_u_TA_CDLIDENTICAL3CROWS __pyx_string_tab[315]
+#define __pyx_n_u_TA_CDLINNECK __pyx_string_tab[316]
+#define __pyx_n_u_TA_CDLINVERTEDHAMMER __pyx_string_tab[317]
+#define __pyx_n_u_TA_CDLKICKING __pyx_string_tab[318]
+#define __pyx_n_u_TA_CDLKICKINGBYLENGTH __pyx_string_tab[319]
+#define __pyx_n_u_TA_CDLLADDERBOTTOM __pyx_string_tab[320]
+#define __pyx_n_u_TA_CDLLONGLEGGEDDOJI __pyx_string_tab[321]
+#define __pyx_n_u_TA_CDLLONGLINE __pyx_string_tab[322]
+#define __pyx_n_u_TA_CDLMARUBOZU __pyx_string_tab[323]
+#define __pyx_n_u_TA_CDLMATCHINGLOW __pyx_string_tab[324]
+#define __pyx_n_u_TA_CDLMATHOLD __pyx_string_tab[325]
+#define __pyx_n_u_TA_CDLMORNINGDOJISTAR __pyx_string_tab[326]
+#define __pyx_n_u_TA_CDLMORNINGSTAR __pyx_string_tab[327]
+#define __pyx_n_u_TA_CDLONNECK __pyx_string_tab[328]
+#define __pyx_n_u_TA_CDLPIERCING __pyx_string_tab[329]
+#define __pyx_n_u_TA_CDLRICKSHAWMAN __pyx_string_tab[330]
+#define __pyx_n_u_TA_CDLRISEFALL3METHODS __pyx_string_tab[331]
+#define __pyx_n_u_TA_CDLSEPARATINGLINES __pyx_string_tab[332]
+#define __pyx_n_u_TA_CDLSHOOTINGSTAR __pyx_string_tab[333]
+#define __pyx_n_u_TA_CDLSHORTLINE __pyx_string_tab[334]
+#define __pyx_n_u_TA_CDLSPINNINGTOP __pyx_string_tab[335]
+#define __pyx_n_u_TA_CDLSTALLEDPATTERN __pyx_string_tab[336]
+#define __pyx_n_u_TA_CDLSTICKSANDWICH __pyx_string_tab[337]
+#define __pyx_n_u_TA_CDLTAKURI __pyx_string_tab[338]
+#define __pyx_n_u_TA_CDLTASUKIGAP __pyx_string_tab[339]
+#define __pyx_n_u_TA_CDLTHRUSTING __pyx_string_tab[340]
+#define __pyx_n_u_TA_CDLTRISTAR __pyx_string_tab[341]
+#define __pyx_n_u_TA_CDLUNIQUE3RIVER __pyx_string_tab[342]
+#define __pyx_n_u_TA_CDLUPSIDEGAP2CROWS __pyx_string_tab[343]
+#define __pyx_n_u_TA_CDLXSIDEGAP3METHODS __pyx_string_tab[344]
+#define __pyx_n_u_TA_CEIL __pyx_string_tab[345]
+#define __pyx_n_u_TA_CMO __pyx_string_tab[346]
+#define __pyx_n_u_TA_CORREL __pyx_string_tab[347]
+#define __pyx_n_u_TA_COS __pyx_string_tab[348]
+#define __pyx_n_u_TA_COSH __pyx_string_tab[349]
+#define __pyx_n_u_TA_DEMA __pyx_string_tab[350]
+#define __pyx_n_u_TA_DIV __pyx_string_tab[351]
+#define __pyx_n_u_TA_DX __pyx_string_tab[352]
+#define __pyx_n_u_TA_EMA __pyx_string_tab[353]
+#define __pyx_n_u_TA_EXP __pyx_string_tab[354]
+#define __pyx_n_u_TA_FLOOR __pyx_string_tab[355]
+#define __pyx_n_u_TA_FUNCTION_NAMES __pyx_string_tab[356]
+#define __pyx_n_u_TA_FUNC_FLAGS __pyx_string_tab[357]
+#define __pyx_n_u_TA_FuncTableAlloc __pyx_string_tab[358]
+#define __pyx_n_u_TA_FuncTableFree __pyx_string_tab[359]
+#define __pyx_n_u_TA_GetFuncHandle __pyx_string_tab[360]
+#define __pyx_n_u_TA_GetFuncInfo __pyx_string_tab[361]
+#define __pyx_n_u_TA_GetInputParameterInfo __pyx_string_tab[362]
+#define __pyx_n_u_TA_GetLookback __pyx_string_tab[363]
+#define __pyx_n_u_TA_GetOptInputParameterInfo __pyx_string_tab[364]
+#define __pyx_n_u_TA_GetOutputParameterInfo __pyx_string_tab[365]
+#define __pyx_n_u_TA_GroupTableAlloc __pyx_string_tab[366]
+#define __pyx_n_u_TA_GroupTableFree __pyx_string_tab[367]
+#define __pyx_n_u_TA_HT_DCPERIOD __pyx_string_tab[368]
+#define __pyx_n_u_TA_HT_DCPHASE __pyx_string_tab[369]
+#define __pyx_n_u_TA_HT_PHASOR __pyx_string_tab[370]
+#define __pyx_n_u_TA_HT_SINE __pyx_string_tab[371]
+#define __pyx_n_u_TA_HT_TRENDLINE __pyx_string_tab[372]
+#define __pyx_n_u_TA_HT_TRENDMODE __pyx_string_tab[373]
+#define __pyx_n_u_TA_IMI __pyx_string_tab[374]
+#define __pyx_n_u_TA_INPUT_FLAGS __pyx_string_tab[375]
+#define __pyx_n_u_TA_Initialize __pyx_string_tab[376]
+#define __pyx_n_u_TA_KAMA __pyx_string_tab[377]
+#define __pyx_n_u_TA_LINEARREG __pyx_string_tab[378]
+#define __pyx_n_u_TA_LINEARREG_ANGLE __pyx_string_tab[379]
+#define __pyx_n_u_TA_LINEARREG_INTERCEPT __pyx_string_tab[380]
+#define __pyx_n_u_TA_LINEARREG_SLOPE __pyx_string_tab[381]
+#define __pyx_n_u_TA_LN __pyx_string_tab[382]
+#define __pyx_n_u_TA_LOG10 __pyx_string_tab[383]
+#define __pyx_n_u_TA_MA __pyx_string_tab[384]
+#define __pyx_n_u_TA_MACD __pyx_string_tab[385]
+#define __pyx_n_u_TA_MACDEXT __pyx_string_tab[386]
+#define __pyx_n_u_TA_MACDFIX __pyx_string_tab[387]
+#define __pyx_n_u_TA_MAMA __pyx_string_tab[388]
+#define __pyx_n_u_TA_MAVP __pyx_string_tab[389]
+#define __pyx_n_u_TA_MAX __pyx_string_tab[390]
+#define __pyx_n_u_TA_MAXINDEX __pyx_string_tab[391]
+#define __pyx_n_u_TA_MEDPRICE __pyx_string_tab[392]
+#define __pyx_n_u_TA_MFI __pyx_string_tab[393]
+#define __pyx_n_u_TA_MIDPOINT __pyx_string_tab[394]
+#define __pyx_n_u_TA_MIDPRICE __pyx_string_tab[395]
+#define __pyx_n_u_TA_MIN __pyx_string_tab[396]
+#define __pyx_n_u_TA_MININDEX __pyx_string_tab[397]
+#define __pyx_n_u_TA_MINMAX __pyx_string_tab[398]
+#define __pyx_n_u_TA_MINMAXINDEX __pyx_string_tab[399]
+#define __pyx_n_u_TA_MINUS_DI __pyx_string_tab[400]
+#define __pyx_n_u_TA_MINUS_DM __pyx_string_tab[401]
+#define __pyx_n_u_TA_MOM __pyx_string_tab[402]
+#define __pyx_n_u_TA_MULT __pyx_string_tab[403]
+#define __pyx_n_u_TA_NATR __pyx_string_tab[404]
+#define __pyx_n_u_TA_OBV __pyx_string_tab[405]
+#define __pyx_n_u_TA_OUTPUT_FLAGS __pyx_string_tab[406]
+#define __pyx_n_u_TA_PLUS_DI __pyx_string_tab[407]
+#define __pyx_n_u_TA_PLUS_DM __pyx_string_tab[408]
+#define __pyx_n_u_TA_PPO __pyx_string_tab[409]
+#define __pyx_n_u_TA_ParamHolderAlloc __pyx_string_tab[410]
+#define __pyx_n_u_TA_ParamHolderFree __pyx_string_tab[411]
+#define __pyx_n_u_TA_ROC __pyx_string_tab[412]
+#define __pyx_n_u_TA_ROCP __pyx_string_tab[413]
+#define __pyx_n_u_TA_ROCR __pyx_string_tab[414]
+#define __pyx_n_u_TA_ROCR100 __pyx_string_tab[415]
+#define __pyx_n_u_TA_RSI __pyx_string_tab[416]
+#define __pyx_n_u_TA_RestoreCandleDefaultSettings __pyx_string_tab[417]
+#define __pyx_n_u_TA_SAR __pyx_string_tab[418]
+#define __pyx_n_u_TA_SAREXT __pyx_string_tab[419]
+#define __pyx_n_u_TA_SIN __pyx_string_tab[420]
+#define __pyx_n_u_TA_SINH __pyx_string_tab[421]
+#define __pyx_n_u_TA_SMA __pyx_string_tab[422]
+#define __pyx_n_u_TA_SQRT __pyx_string_tab[423]
+#define __pyx_n_u_TA_STDDEV __pyx_string_tab[424]
+#define __pyx_n_u_TA_STOCH __pyx_string_tab[425]
+#define __pyx_n_u_TA_STOCHF __pyx_string_tab[426]
+#define __pyx_n_u_TA_STOCHRSI __pyx_string_tab[427]
+#define __pyx_n_u_TA_SUB __pyx_string_tab[428]
+#define __pyx_n_u_TA_SUM __pyx_string_tab[429]
+#define __pyx_n_u_TA_SetCandleSettings __pyx_string_tab[430]
+#define __pyx_n_u_TA_SetCompatibility __pyx_string_tab[431]
+#define __pyx_n_u_TA_SetOptInputParamInteger __pyx_string_tab[432]
+#define __pyx_n_u_TA_SetOptInputParamReal __pyx_string_tab[433]
+#define __pyx_n_u_TA_SetUnstablePeriod __pyx_string_tab[434]
+#define __pyx_n_u_TA_Shutdown __pyx_string_tab[435]
+#define __pyx_n_u_TA_T3 __pyx_string_tab[436]
+#define __pyx_n_u_TA_TAN __pyx_string_tab[437]
+#define __pyx_n_u_TA_TANH __pyx_string_tab[438]
+#define __pyx_n_u_TA_TEMA __pyx_string_tab[439]
+#define __pyx_n_u_TA_TRANGE __pyx_string_tab[440]
+#define __pyx_n_u_TA_TRIMA __pyx_string_tab[441]
+#define __pyx_n_u_TA_TRIX __pyx_string_tab[442]
+#define __pyx_n_u_TA_TSF __pyx_string_tab[443]
+#define __pyx_n_u_TA_TYPPRICE __pyx_string_tab[444]
+#define __pyx_n_u_TA_ULTOSC __pyx_string_tab[445]
+#define __pyx_n_u_TA_VAR __pyx_string_tab[446]
+#define __pyx_n_u_TA_WCLPRICE __pyx_string_tab[447]
+#define __pyx_n_u_TA_WILLR __pyx_string_tab[448]
+#define __pyx_n_u_TA_WMA __pyx_string_tab[449]
+#define __pyx_n_u_TEMA __pyx_string_tab[450]
+#define __pyx_n_u_TRANGE __pyx_string_tab[451]
+#define __pyx_n_u_TRIMA __pyx_string_tab[452]
+#define __pyx_n_u_TRIX __pyx_string_tab[453]
+#define __pyx_n_u_TSF __pyx_string_tab[454]
+#define __pyx_n_u_TYPPRICE __pyx_string_tab[455]
+#define __pyx_kp_u_This_is_a_pythonic_wrapper_arou __pyx_string_tab[456]
+#define __pyx_kp_u_Too_many_price_arguments_expecte __pyx_string_tab[457]
+#define __pyx_kp_u_Triangular_Moving_Average __pyx_string_tab[458]
+#define __pyx_kp_u_Triple_Exponential_Moving_Averag __pyx_string_tab[459]
+#define __pyx_kp_u_Triple_Generalized_Double_Expone __pyx_string_tab[460]
+#define __pyx_n_u_TypeError __pyx_string_tab[461]
+#define __pyx_n_u_ULTOSC __pyx_string_tab[462]
+#define __pyx_kp_u_Unknown_Error __pyx_string_tab[463]
+#define __pyx_kp_u_Unknown_Error_TA_UNKNOWN_ERR __pyx_string_tab[464]
+#define __pyx_n_u_VAR __pyx_string_tab[465]
+#define __pyx_kp_u_Values_represent_a_lower_limit __pyx_string_tab[466]
+#define __pyx_kp_u_Values_represent_an_upper_limit __pyx_string_tab[467]
+#define __pyx_n_u_WCLPRICE __pyx_string_tab[468]
+#define __pyx_n_u_WILLR __pyx_string_tab[469]
+#define __pyx_n_u_WMA __pyx_string_tab[470]
+#define __pyx_kp_u_Weighted_Moving_Average __pyx_string_tab[471]
+#define __pyx_kp_u__10 __pyx_string_tab[472]
+#define __pyx_kp_u__11 __pyx_string_tab[473]
+#define __pyx_kp_u__12 __pyx_string_tab[474]
+#define __pyx_kp_u__13 __pyx_string_tab[475]
+#define __pyx_kp_u__14 __pyx_string_tab[476]
+#define __pyx_kp_u__15 __pyx_string_tab[477]
+#define __pyx_kp_u__2 __pyx_string_tab[478]
+#define __pyx_kp_u__3 __pyx_string_tab[479]
+#define __pyx_kp_u__4 __pyx_string_tab[480]
+#define __pyx_kp_u__5 __pyx_string_tab[481]
+#define __pyx_kp_u__6 __pyx_string_tab[482]
+#define __pyx_kp_u__7 __pyx_string_tab[483]
+#define __pyx_kp_u__8 __pyx_string_tab[484]
+#define __pyx_kp_u__9 __pyx_string_tab[485]
+#define __pyx_n_u_acceleration __pyx_string_tab[486]
+#define __pyx_n_u_accelerationinitlong __pyx_string_tab[487]
+#define __pyx_n_u_accelerationinitshort __pyx_string_tab[488]
+#define __pyx_n_u_accelerationlong __pyx_string_tab[489]
+#define __pyx_n_u_accelerationmaxlong __pyx_string_tab[490]
+#define __pyx_n_u_accelerationmaxshort __pyx_string_tab[491]
+#define __pyx_n_u_accelerationshort __pyx_string_tab[492]
+#define __pyx_kp_u_add_note __pyx_string_tab[493]
+#define __pyx_n_u_all __pyx_string_tab[494]
+#define __pyx_kp_u_any_ndarray __pyx_string_tab[495]
+#define __pyx_n_u_append __pyx_string_tab[496]
+#define __pyx_n_u_arg __pyx_string_tab[497]
+#define __pyx_n_u_args __pyx_string_tab[498]
+#define __pyx_n_u_ascii __pyx_string_tab[499]
+#define __pyx_n_u_astype __pyx_string_tab[500]
+#define __pyx_n_u_asyncio_coroutines __pyx_string_tab[501]
+#define __pyx_n_u_avgperiod __pyx_string_tab[502]
+#define __pyx_n_u_b __pyx_string_tab[503]
+#define __pyx_n_u_begidx __pyx_string_tab[504]
+#define __pyx_n_u_bytes2str __pyx_string_tab[505]
+#define __pyx_n_u_call __pyx_string_tab[506]
+#define __pyx_n_u_call_function __pyx_string_tab[507]
+#define __pyx_n_u_check_opt_input_value __pyx_string_tab[508]
+#define __pyx_n_u_class_getitem __pyx_string_tab[509]
+#define __pyx_n_u_cline_in_traceback __pyx_string_tab[510]
+#define __pyx_n_u_clone __pyx_string_tab[511]
+#define __pyx_n_u_close __pyx_string_tab[512]
+#define __pyx_n_u_close_data __pyx_string_tab[513]
+#define __pyx_n_u_collections __pyx_string_tab[514]
+#define __pyx_n_u_column_stack __pyx_string_tab[515]
+#define __pyx_n_u_columns __pyx_string_tab[516]
+#define __pyx_n_u_copy __pyx_string_tab[517]
+#define __pyx_n_u_d __pyx_string_tab[518]
+#define __pyx_n_u_decode __pyx_string_tab[519]
+#define __pyx_n_u_default_value __pyx_string_tab[520]
+#define __pyx_n_u_defaults __pyx_string_tab[521]
+#define __pyx_n_u_display_name __pyx_string_tab[522]
+#define __pyx_kp_u_display_name_s_group_s __pyx_string_tab[523]
+#define __pyx_n_u_doc __pyx_string_tab[524]
+#define __pyx_n_u_docs __pyx_string_tab[525]
+#define __pyx_n_u_documentation __pyx_string_tab[526]
+#define __pyx_n_u_empty __pyx_string_tab[527]
+#define __pyx_n_u_endidx __pyx_string_tab[528]
+#define __pyx_n_u_enumerate __pyx_string_tab[529]
+#define __pyx_kp_u_expected __pyx_string_tab[530]
+#define __pyx_n_u_factor __pyx_string_tab[531]
+#define __pyx_n_u_fastd_matype __pyx_string_tab[532]
+#define __pyx_n_u_fastd_period __pyx_string_tab[533]
+#define __pyx_n_u_fastk_period __pyx_string_tab[534]
+#define __pyx_n_u_fastlimit __pyx_string_tab[535]
+#define __pyx_n_u_fastmatype __pyx_string_tab[536]
+#define __pyx_n_u_fastperiod __pyx_string_tab[537]
+#define __pyx_n_u_flag __pyx_string_tab[538]
+#define __pyx_n_u_flags __pyx_string_tab[539]
+#define __pyx_n_u_flags_lookup_dict __pyx_string_tab[540]
+#define __pyx_n_u_func __pyx_string_tab[541]
+#define __pyx_n_u_func_args __pyx_string_tab[542]
+#define __pyx_n_u_func_info __pyx_string_tab[543]
+#define __pyx_n_u_func_line __pyx_string_tab[544]
+#define __pyx_n_u_func_object __pyx_string_tab[545]
+#define __pyx_kp_u_function_failed_with_error_code __pyx_string_tab[546]
+#define __pyx_n_u_function_flags __pyx_string_tab[547]
+#define __pyx_n_u_function_name __pyx_string_tab[548]
+#define __pyx_n_u_functions __pyx_string_tab[549]
+#define __pyx_n_u_get_defaults_and_docs __pyx_string_tab[550]
+#define __pyx_n_u_get_flags __pyx_string_tab[551]
+#define __pyx_n_u_get_input_arrays __pyx_string_tab[552]
+#define __pyx_n_u_get_input_names __pyx_string_tab[553]
+#define __pyx_n_u_get_opt_input_value __pyx_string_tab[554]
+#define __pyx_n_u_get_parameters __pyx_string_tab[555]
+#define __pyx_n_u_getitem __pyx_string_tab[556]
+#define __pyx_kp_u_got __pyx_string_tab[557]
+#define __pyx_n_u_group __pyx_string_tab[558]
+#define __pyx_n_u_groups __pyx_string_tab[559]
+#define __pyx_n_u_help __pyx_string_tab[560]
+#define __pyx_n_u_high __pyx_string_tab[561]
+#define __pyx_n_u_high_data __pyx_string_tab[562]
+#define __pyx_n_u_holder __pyx_string_tab[563]
+#define __pyx_n_u_i __pyx_string_tab[564]
+#define __pyx_n_u_id __pyx_string_tab[565]
+#define __pyx_n_u_idx __pyx_string_tab[566]
+#define __pyx_n_u_import_error __pyx_string_tab[567]
+#define __pyx_n_u_in __pyx_string_tab[568]
+#define __pyx_n_u_index __pyx_string_tab[569]
+#define __pyx_n_u_info __pyx_string_tab[570]
+#define __pyx_n_u_init __pyx_string_tab[571]
+#define __pyx_n_u_initializing __pyx_string_tab[572]
+#define __pyx_kp_u_input_array_has_wrong_dimensions __pyx_string_tab[573]
+#define __pyx_kp_u_input_array_lengths_are_differen __pyx_string_tab[574]
+#define __pyx_kp_u_input_array_type_is_not_double __pyx_string_tab[575]
+#define __pyx_n_u_input_arrays __pyx_string_tab[576]
+#define __pyx_kp_u_input_arrays_2 __pyx_string_tab[577]
+#define __pyx_kp_u_input_arrays_parameter_missing_r __pyx_string_tab[578]
+#define __pyx_n_u_input_name __pyx_string_tab[579]
+#define __pyx_n_u_input_names __pyx_string_tab[580]
+#define __pyx_n_u_input_price_series_names __pyx_string_tab[581]
+#define __pyx_n_u_input_price_series_names_2 __pyx_string_tab[582]
+#define __pyx_n_u_integer __pyx_string_tab[583]
+#define __pyx_kp_u_integer_values_are_100_0_or_100 __pyx_string_tab[584]
+#define __pyx_n_u_is_coroutine __pyx_string_tab[585]
+#define __pyx_n_u_is_empty __pyx_string_tab[586]
+#define __pyx_n_u_items __pyx_string_tab[587]
+#define __pyx_n_u_key __pyx_string_tab[588]
+#define __pyx_n_u_keys __pyx_string_tab[589]
+#define __pyx_n_u_kwargs __pyx_string_tab[590]
+#define __pyx_n_u_length __pyx_string_tab[591]
+#define __pyx_n_u_local __pyx_string_tab[592]
+#define __pyx_n_u_local_2 __pyx_string_tab[593]
+#define __pyx_n_u_log __pyx_string_tab[594]
+#define __pyx_n_u_lookback __pyx_string_tab[595]
+#define __pyx_n_u_lookup __pyx_string_tab[596]
+#define __pyx_n_u_low __pyx_string_tab[597]
+#define __pyx_n_u_low_data __pyx_string_tab[598]
+#define __pyx_n_u_lower __pyx_string_tab[599]
+#define __pyx_n_u_main __pyx_string_tab[600]
+#define __pyx_n_u_math __pyx_string_tab[601]
+#define __pyx_n_u_matype __pyx_string_tab[602]
+#define __pyx_n_u_max __pyx_string_tab[603]
+#define __pyx_n_u_max_int __pyx_string_tab[604]
+#define __pyx_n_u_maximum __pyx_string_tab[605]
+#define __pyx_n_u_maxperiod __pyx_string_tab[606]
+#define __pyx_n_u_metaclass __pyx_string_tab[607]
+#define __pyx_n_u_min __pyx_string_tab[608]
+#define __pyx_n_u_min_int __pyx_string_tab[609]
+#define __pyx_n_u_minperiod __pyx_string_tab[610]
+#define __pyx_n_u_missing __pyx_string_tab[611]
+#define __pyx_n_u_missing_keys __pyx_string_tab[612]
+#define __pyx_n_u_module __pyx_string_tab[613]
+#define __pyx_n_u_mro_entries __pyx_string_tab[614]
+#define __pyx_n_u_msg __pyx_string_tab[615]
+#define __pyx_n_u_n __pyx_string_tab[616]
+#define __pyx_n_u_name __pyx_string_tab[617]
+#define __pyx_n_u_name_2 __pyx_string_tab[618]
+#define __pyx_n_u_nan __pyx_string_tab[619]
+#define __pyx_n_u_nbdev __pyx_string_tab[620]
+#define __pyx_n_u_nbdevdn __pyx_string_tab[621]
+#define __pyx_n_u_nbdevup __pyx_string_tab[622]
+#define __pyx_n_u_no_existing_input_arrays __pyx_string_tab[623]
+#define __pyx_n_u_num_inputs __pyx_string_tab[624]
+#define __pyx_n_u_num_opt_inputs __pyx_string_tab[625]
+#define __pyx_n_u_num_outputs __pyx_string_tab[626]
+#define __pyx_n_u_numpy __pyx_string_tab[627]
+#define __pyx_kp_u_numpy__core_multiarray_failed_to __pyx_string_tab[628]
+#define __pyx_kp_u_numpy__core_umath_failed_to_impo __pyx_string_tab[629]
+#define __pyx_n_u_object __pyx_string_tab[630]
+#define __pyx_n_u_offsetonreverse __pyx_string_tab[631]
+#define __pyx_n_u_open __pyx_string_tab[632]
+#define __pyx_n_u_openInterest __pyx_string_tab[633]
+#define __pyx_n_u_open_data __pyx_string_tab[634]
+#define __pyx_n_u_optIn __pyx_string_tab[635]
+#define __pyx_n_u_opt_input __pyx_string_tab[636]
+#define __pyx_n_u_opt_input_values __pyx_string_tab[637]
+#define __pyx_n_u_opt_inputs __pyx_string_tab[638]
+#define __pyx_n_u_ordereddict __pyx_string_tab[639]
+#define __pyx_n_u_out __pyx_string_tab[640]
+#define __pyx_n_u_outaroondown __pyx_string_tab[641]
+#define __pyx_n_u_outaroonup __pyx_string_tab[642]
+#define __pyx_n_u_outbegidx __pyx_string_tab[643]
+#define __pyx_n_u_outfama __pyx_string_tab[644]
+#define __pyx_n_u_outfastd __pyx_string_tab[645]
+#define __pyx_n_u_outfastk __pyx_string_tab[646]
+#define __pyx_n_u_outinphase __pyx_string_tab[647]
+#define __pyx_n_u_outinteger __pyx_string_tab[648]
+#define __pyx_n_u_outinteger_data __pyx_string_tab[649]
+#define __pyx_n_u_outleadsine __pyx_string_tab[650]
+#define __pyx_n_u_outmacd __pyx_string_tab[651]
+#define __pyx_n_u_outmacdhist __pyx_string_tab[652]
+#define __pyx_n_u_outmacdsignal __pyx_string_tab[653]
+#define __pyx_n_u_outmama __pyx_string_tab[654]
+#define __pyx_n_u_outmax __pyx_string_tab[655]
+#define __pyx_n_u_outmaxidx __pyx_string_tab[656]
+#define __pyx_n_u_outmaxidx_data __pyx_string_tab[657]
+#define __pyx_n_u_outmin __pyx_string_tab[658]
+#define __pyx_n_u_outminidx __pyx_string_tab[659]
+#define __pyx_n_u_outminidx_data __pyx_string_tab[660]
+#define __pyx_n_u_outnbelement __pyx_string_tab[661]
+#define __pyx_n_u_output __pyx_string_tab[662]
+#define __pyx_n_u_output_flags __pyx_string_tab[663]
+#define __pyx_n_u_output_name __pyx_string_tab[664]
+#define __pyx_n_u_output_names __pyx_string_tab[665]
+#define __pyx_n_u_outputs __pyx_string_tab[666]
+#define __pyx_n_u_outputs_valid __pyx_string_tab[667]
+#define __pyx_n_u_outquadrature __pyx_string_tab[668]
+#define __pyx_n_u_outreal __pyx_string_tab[669]
+#define __pyx_n_u_outreallowerband __pyx_string_tab[670]
+#define __pyx_n_u_outrealmiddleband __pyx_string_tab[671]
+#define __pyx_n_u_outrealupperband __pyx_string_tab[672]
+#define __pyx_n_u_outsine __pyx_string_tab[673]
+#define __pyx_n_u_outslowd __pyx_string_tab[674]
+#define __pyx_n_u_outslowk __pyx_string_tab[675]
+#define __pyx_n_u_pandas __pyx_string_tab[676]
+#define __pyx_n_u_param __pyx_string_tab[677]
+#define __pyx_n_u_param_name __pyx_string_tab[678]
+#define __pyx_n_u_parameters __pyx_string_tab[679]
+#define __pyx_n_u_params __pyx_string_tab[680]
+#define __pyx_n_u_penetration __pyx_string_tab[681]
+#define __pyx_n_u_period __pyx_string_tab[682]
+#define __pyx_n_u_periods __pyx_string_tab[683]
+#define __pyx_n_u_periods_data __pyx_string_tab[684]
+#define __pyx_n_u_polars __pyx_string_tab[685]
+#define __pyx_n_u_pop __pyx_string_tab[686]
+#define __pyx_n_u_prepare __pyx_string_tab[687]
+#define __pyx_n_u_price __pyx_string_tab[688]
+#define __pyx_n_u_price0 __pyx_string_tab[689]
+#define __pyx_n_u_price1 __pyx_string_tab[690]
+#define __pyx_n_u_price_series __pyx_string_tab[691]
+#define __pyx_n_u_price_series_name_values __pyx_string_tab[692]
+#define __pyx_n_u_prices __pyx_string_tab[693]
+#define __pyx_n_u_property __pyx_string_tab[694]
+#define __pyx_n_u_qualname __pyx_string_tab[695]
+#define __pyx_n_u_range __pyx_string_tab[696]
+#define __pyx_n_u_rangetype __pyx_string_tab[697]
+#define __pyx_n_u_real __pyx_string_tab[698]
+#define __pyx_n_u_real0 __pyx_string_tab[699]
+#define __pyx_n_u_real0_data __pyx_string_tab[700]
+#define __pyx_n_u_real1 __pyx_string_tab[701]
+#define __pyx_n_u_real1_data __pyx_string_tab[702]
+#define __pyx_n_u_real_data __pyx_string_tab[703]
+#define __pyx_n_u_replace __pyx_string_tab[704]
+#define __pyx_n_u_repr __pyx_string_tab[705]
+#define __pyx_n_u_results __pyx_string_tab[706]
+#define __pyx_n_u_ret __pyx_string_tab[707]
+#define __pyx_n_u_retCode __pyx_string_tab[708]
+#define __pyx_n_u_ret_code __pyx_string_tab[709]
+#define __pyx_n_u_run __pyx_string_tab[710]
+#define __pyx_n_u_s __pyx_string_tab[711]
+#define __pyx_kp_u_s_2 __pyx_string_tab[712]
+#define __pyx_kp_u_s_3 __pyx_string_tab[713]
+#define __pyx_kp_u_s_4 __pyx_string_tab[714]
+#define __pyx_n_u_schema __pyx_string_tab[715]
+#define __pyx_n_u_self __pyx_string_tab[716]
+#define __pyx_n_u_series __pyx_string_tab[717]
+#define __pyx_n_u_set_function_args __pyx_string_tab[718]
+#define __pyx_n_u_set_input_arrays __pyx_string_tab[719]
+#define __pyx_n_u_set_input_names __pyx_string_tab[720]
+#define __pyx_n_u_set_name __pyx_string_tab[721]
+#define __pyx_n_u_set_parameters __pyx_string_tab[722]
+#define __pyx_n_u_settingtype __pyx_string_tab[723]
+#define __pyx_n_u_signalmatype __pyx_string_tab[724]
+#define __pyx_n_u_signalperiod __pyx_string_tab[725]
+#define __pyx_n_u_skip_first __pyx_string_tab[726]
+#define __pyx_n_u_slowd_matype __pyx_string_tab[727]
+#define __pyx_n_u_slowd_period __pyx_string_tab[728]
+#define __pyx_n_u_slowk_matype __pyx_string_tab[729]
+#define __pyx_n_u_slowk_period __pyx_string_tab[730]
+#define __pyx_n_u_slowlimit __pyx_string_tab[731]
+#define __pyx_n_u_slowmatype __pyx_string_tab[732]
+#define __pyx_n_u_slowperiod __pyx_string_tab[733]
+#define __pyx_n_u_spec __pyx_string_tab[734]
+#define __pyx_n_u_startvalue __pyx_string_tab[735]
+#define __pyx_n_u_str __pyx_string_tab[736]
+#define __pyx_n_u_str2bytes __pyx_string_tab[737]
+#define __pyx_n_u_stream_ACCBANDS __pyx_string_tab[738]
+#define __pyx_n_u_stream_ACOS __pyx_string_tab[739]
+#define __pyx_n_u_stream_AD __pyx_string_tab[740]
+#define __pyx_n_u_stream_ADD __pyx_string_tab[741]
+#define __pyx_n_u_stream_ADOSC __pyx_string_tab[742]
+#define __pyx_n_u_stream_ADX __pyx_string_tab[743]
+#define __pyx_n_u_stream_ADXR __pyx_string_tab[744]
+#define __pyx_n_u_stream_APO __pyx_string_tab[745]
+#define __pyx_n_u_stream_AROON __pyx_string_tab[746]
+#define __pyx_n_u_stream_AROONOSC __pyx_string_tab[747]
+#define __pyx_n_u_stream_ASIN __pyx_string_tab[748]
+#define __pyx_n_u_stream_ATAN __pyx_string_tab[749]
+#define __pyx_n_u_stream_ATR __pyx_string_tab[750]
+#define __pyx_n_u_stream_AVGDEV __pyx_string_tab[751]
+#define __pyx_n_u_stream_AVGPRICE __pyx_string_tab[752]
+#define __pyx_n_u_stream_BBANDS __pyx_string_tab[753]
+#define __pyx_n_u_stream_BETA __pyx_string_tab[754]
+#define __pyx_n_u_stream_BOP __pyx_string_tab[755]
+#define __pyx_n_u_stream_CCI __pyx_string_tab[756]
+#define __pyx_n_u_stream_CDL2CROWS __pyx_string_tab[757]
+#define __pyx_n_u_stream_CDL3BLACKCROWS __pyx_string_tab[758]
+#define __pyx_n_u_stream_CDL3INSIDE __pyx_string_tab[759]
+#define __pyx_n_u_stream_CDL3LINESTRIKE __pyx_string_tab[760]
+#define __pyx_n_u_stream_CDL3OUTSIDE __pyx_string_tab[761]
+#define __pyx_n_u_stream_CDL3STARSINSOUTH __pyx_string_tab[762]
+#define __pyx_n_u_stream_CDL3WHITESOLDIERS __pyx_string_tab[763]
+#define __pyx_n_u_stream_CDLABANDONEDBABY __pyx_string_tab[764]
+#define __pyx_n_u_stream_CDLADVANCEBLOCK __pyx_string_tab[765]
+#define __pyx_n_u_stream_CDLBELTHOLD __pyx_string_tab[766]
+#define __pyx_n_u_stream_CDLBREAKAWAY __pyx_string_tab[767]
+#define __pyx_n_u_stream_CDLCLOSINGMARUBOZU __pyx_string_tab[768]
+#define __pyx_n_u_stream_CDLCONCEALBABYSWALL __pyx_string_tab[769]
+#define __pyx_n_u_stream_CDLCOUNTERATTACK __pyx_string_tab[770]
+#define __pyx_n_u_stream_CDLDARKCLOUDCOVER __pyx_string_tab[771]
+#define __pyx_n_u_stream_CDLDOJI __pyx_string_tab[772]
+#define __pyx_n_u_stream_CDLDOJISTAR __pyx_string_tab[773]
+#define __pyx_n_u_stream_CDLDRAGONFLYDOJI __pyx_string_tab[774]
+#define __pyx_n_u_stream_CDLENGULFING __pyx_string_tab[775]
+#define __pyx_n_u_stream_CDLEVENINGDOJISTAR __pyx_string_tab[776]
+#define __pyx_n_u_stream_CDLEVENINGSTAR __pyx_string_tab[777]
+#define __pyx_n_u_stream_CDLGAPSIDESIDEWHITE __pyx_string_tab[778]
+#define __pyx_n_u_stream_CDLGRAVESTONEDOJI __pyx_string_tab[779]
+#define __pyx_n_u_stream_CDLHAMMER __pyx_string_tab[780]
+#define __pyx_n_u_stream_CDLHANGINGMAN __pyx_string_tab[781]
+#define __pyx_n_u_stream_CDLHARAMI __pyx_string_tab[782]
+#define __pyx_n_u_stream_CDLHARAMICROSS __pyx_string_tab[783]
+#define __pyx_n_u_stream_CDLHIGHWAVE __pyx_string_tab[784]
+#define __pyx_n_u_stream_CDLHIKKAKE __pyx_string_tab[785]
+#define __pyx_n_u_stream_CDLHIKKAKEMOD __pyx_string_tab[786]
+#define __pyx_n_u_stream_CDLHOMINGPIGEON __pyx_string_tab[787]
+#define __pyx_n_u_stream_CDLIDENTICAL3CROWS __pyx_string_tab[788]
+#define __pyx_n_u_stream_CDLINNECK __pyx_string_tab[789]
+#define __pyx_n_u_stream_CDLINVERTEDHAMMER __pyx_string_tab[790]
+#define __pyx_n_u_stream_CDLKICKING __pyx_string_tab[791]
+#define __pyx_n_u_stream_CDLKICKINGBYLENGTH __pyx_string_tab[792]
+#define __pyx_n_u_stream_CDLLADDERBOTTOM __pyx_string_tab[793]
+#define __pyx_n_u_stream_CDLLONGLEGGEDDOJI __pyx_string_tab[794]
+#define __pyx_n_u_stream_CDLLONGLINE __pyx_string_tab[795]
+#define __pyx_n_u_stream_CDLMARUBOZU __pyx_string_tab[796]
+#define __pyx_n_u_stream_CDLMATCHINGLOW __pyx_string_tab[797]
+#define __pyx_n_u_stream_CDLMATHOLD __pyx_string_tab[798]
+#define __pyx_n_u_stream_CDLMORNINGDOJISTAR __pyx_string_tab[799]
+#define __pyx_n_u_stream_CDLMORNINGSTAR __pyx_string_tab[800]
+#define __pyx_n_u_stream_CDLONNECK __pyx_string_tab[801]
+#define __pyx_n_u_stream_CDLPIERCING __pyx_string_tab[802]
+#define __pyx_n_u_stream_CDLRICKSHAWMAN __pyx_string_tab[803]
+#define __pyx_n_u_stream_CDLRISEFALL3METHODS __pyx_string_tab[804]
+#define __pyx_n_u_stream_CDLSEPARATINGLINES __pyx_string_tab[805]
+#define __pyx_n_u_stream_CDLSHOOTINGSTAR __pyx_string_tab[806]
+#define __pyx_n_u_stream_CDLSHORTLINE __pyx_string_tab[807]
+#define __pyx_n_u_stream_CDLSPINNINGTOP __pyx_string_tab[808]
+#define __pyx_n_u_stream_CDLSTALLEDPATTERN __pyx_string_tab[809]
+#define __pyx_n_u_stream_CDLSTICKSANDWICH __pyx_string_tab[810]
+#define __pyx_n_u_stream_CDLTAKURI __pyx_string_tab[811]
+#define __pyx_n_u_stream_CDLTASUKIGAP __pyx_string_tab[812]
+#define __pyx_n_u_stream_CDLTHRUSTING __pyx_string_tab[813]
+#define __pyx_n_u_stream_CDLTRISTAR __pyx_string_tab[814]
+#define __pyx_n_u_stream_CDLUNIQUE3RIVER __pyx_string_tab[815]
+#define __pyx_n_u_stream_CDLUPSIDEGAP2CROWS __pyx_string_tab[816]
+#define __pyx_n_u_stream_CDLXSIDEGAP3METHODS __pyx_string_tab[817]
+#define __pyx_n_u_stream_CEIL __pyx_string_tab[818]
+#define __pyx_n_u_stream_CMO __pyx_string_tab[819]
+#define __pyx_n_u_stream_CORREL __pyx_string_tab[820]
+#define __pyx_n_u_stream_COS __pyx_string_tab[821]
+#define __pyx_n_u_stream_COSH __pyx_string_tab[822]
+#define __pyx_n_u_stream_DEMA __pyx_string_tab[823]
+#define __pyx_n_u_stream_DIV __pyx_string_tab[824]
+#define __pyx_n_u_stream_DX __pyx_string_tab[825]
+#define __pyx_n_u_stream_EMA __pyx_string_tab[826]
+#define __pyx_n_u_stream_EXP __pyx_string_tab[827]
+#define __pyx_n_u_stream_FLOOR __pyx_string_tab[828]
+#define __pyx_n_u_stream_HT_DCPERIOD __pyx_string_tab[829]
+#define __pyx_n_u_stream_HT_DCPHASE __pyx_string_tab[830]
+#define __pyx_n_u_stream_HT_PHASOR __pyx_string_tab[831]
+#define __pyx_n_u_stream_HT_SINE __pyx_string_tab[832]
+#define __pyx_n_u_stream_HT_TRENDLINE __pyx_string_tab[833]
+#define __pyx_n_u_stream_HT_TRENDMODE __pyx_string_tab[834]
+#define __pyx_n_u_stream_IMI __pyx_string_tab[835]
+#define __pyx_n_u_stream_KAMA __pyx_string_tab[836]
+#define __pyx_n_u_stream_LINEARREG __pyx_string_tab[837]
+#define __pyx_n_u_stream_LINEARREG_ANGLE __pyx_string_tab[838]
+#define __pyx_n_u_stream_LINEARREG_INTERCEPT __pyx_string_tab[839]
+#define __pyx_n_u_stream_LINEARREG_SLOPE __pyx_string_tab[840]
+#define __pyx_n_u_stream_LN __pyx_string_tab[841]
+#define __pyx_n_u_stream_LOG10 __pyx_string_tab[842]
+#define __pyx_n_u_stream_MA __pyx_string_tab[843]
+#define __pyx_n_u_stream_MACD __pyx_string_tab[844]
+#define __pyx_n_u_stream_MACDEXT __pyx_string_tab[845]
+#define __pyx_n_u_stream_MACDFIX __pyx_string_tab[846]
+#define __pyx_n_u_stream_MAMA __pyx_string_tab[847]
+#define __pyx_n_u_stream_MAVP __pyx_string_tab[848]
+#define __pyx_n_u_stream_MAX __pyx_string_tab[849]
+#define __pyx_n_u_stream_MAXINDEX __pyx_string_tab[850]
+#define __pyx_n_u_stream_MEDPRICE __pyx_string_tab[851]
+#define __pyx_n_u_stream_MFI __pyx_string_tab[852]
+#define __pyx_n_u_stream_MIDPOINT __pyx_string_tab[853]
+#define __pyx_n_u_stream_MIDPRICE __pyx_string_tab[854]
+#define __pyx_n_u_stream_MIN __pyx_string_tab[855]
+#define __pyx_n_u_stream_MININDEX __pyx_string_tab[856]
+#define __pyx_n_u_stream_MINMAX __pyx_string_tab[857]
+#define __pyx_n_u_stream_MINMAXINDEX __pyx_string_tab[858]
+#define __pyx_n_u_stream_MINUS_DI __pyx_string_tab[859]
+#define __pyx_n_u_stream_MINUS_DM __pyx_string_tab[860]
+#define __pyx_n_u_stream_MOM __pyx_string_tab[861]
+#define __pyx_n_u_stream_MULT __pyx_string_tab[862]
+#define __pyx_n_u_stream_NATR __pyx_string_tab[863]
+#define __pyx_n_u_stream_OBV __pyx_string_tab[864]
+#define __pyx_n_u_stream_PLUS_DI __pyx_string_tab[865]
+#define __pyx_n_u_stream_PLUS_DM __pyx_string_tab[866]
+#define __pyx_n_u_stream_PPO __pyx_string_tab[867]
+#define __pyx_n_u_stream_ROC __pyx_string_tab[868]
+#define __pyx_n_u_stream_ROCP __pyx_string_tab[869]
+#define __pyx_n_u_stream_ROCR __pyx_string_tab[870]
+#define __pyx_n_u_stream_ROCR100 __pyx_string_tab[871]
+#define __pyx_n_u_stream_RSI __pyx_string_tab[872]
+#define __pyx_n_u_stream_SAR __pyx_string_tab[873]
+#define __pyx_n_u_stream_SAREXT __pyx_string_tab[874]
+#define __pyx_n_u_stream_SIN __pyx_string_tab[875]
+#define __pyx_n_u_stream_SINH __pyx_string_tab[876]
+#define __pyx_n_u_stream_SMA __pyx_string_tab[877]
+#define __pyx_n_u_stream_SQRT __pyx_string_tab[878]
+#define __pyx_n_u_stream_STDDEV __pyx_string_tab[879]
+#define __pyx_n_u_stream_STOCH __pyx_string_tab[880]
+#define __pyx_n_u_stream_STOCHF __pyx_string_tab[881]
+#define __pyx_n_u_stream_STOCHRSI __pyx_string_tab[882]
+#define __pyx_n_u_stream_SUB __pyx_string_tab[883]
+#define __pyx_n_u_stream_SUM __pyx_string_tab[884]
+#define __pyx_n_u_stream_T3 __pyx_string_tab[885]
+#define __pyx_n_u_stream_TAN __pyx_string_tab[886]
+#define __pyx_n_u_stream_TANH __pyx_string_tab[887]
+#define __pyx_n_u_stream_TEMA __pyx_string_tab[888]
+#define __pyx_n_u_stream_TRANGE __pyx_string_tab[889]
+#define __pyx_n_u_stream_TRIMA __pyx_string_tab[890]
+#define __pyx_n_u_stream_TRIX __pyx_string_tab[891]
+#define __pyx_n_u_stream_TSF __pyx_string_tab[892]
+#define __pyx_n_u_stream_TYPPRICE __pyx_string_tab[893]
+#define __pyx_n_u_stream_ULTOSC __pyx_string_tab[894]
+#define __pyx_n_u_stream_VAR __pyx_string_tab[895]
+#define __pyx_n_u_stream_WCLPRICE __pyx_string_tab[896]
+#define __pyx_n_u_stream_WILLR __pyx_string_tab[897]
+#define __pyx_n_u_stream_WMA __pyx_string_tab[898]
+#define __pyx_kp_u_stream__s __pyx_string_tab[899]
+#define __pyx_n_u_sys __pyx_string_tab[900]
+#define __pyx_n_u_ta_check_success __pyx_string_tab[901]
+#define __pyx_n_u_ta_func_unst_ids __pyx_string_tab[902]
+#define __pyx_n_u_ta_getFuncInfo __pyx_string_tab[903]
+#define __pyx_n_u_ta_getFuncTable __pyx_string_tab[904]
+#define __pyx_n_u_ta_getGroupTable __pyx_string_tab[905]
+#define __pyx_n_u_ta_getInputParameterInfo __pyx_string_tab[906]
+#define __pyx_n_u_ta_getOptInputParameterInfo __pyx_string_tab[907]
+#define __pyx_n_u_ta_getOutputParameterInfo __pyx_string_tab[908]
+#define __pyx_n_u_ta_get_compatibility __pyx_string_tab[909]
+#define __pyx_n_u_ta_get_unstable_period __pyx_string_tab[910]
+#define __pyx_n_u_ta_initialize __pyx_string_tab[911]
+#define __pyx_n_u_ta_restore_candle_default_setti __pyx_string_tab[912]
+#define __pyx_n_u_ta_set_candle_settings __pyx_string_tab[913]
+#define __pyx_n_u_ta_set_compatibility __pyx_string_tab[914]
+#define __pyx_n_u_ta_set_unstable_period __pyx_string_tab[915]
+#define __pyx_n_u_ta_shutdown __pyx_string_tab[916]
+#define __pyx_n_u_ta_version __pyx_string_tab[917]
+#define __pyx_n_u_table __pyx_string_tab[918]
+#define __pyx_kp_u_talib__abstract_pxi __pyx_string_tab[919]
+#define __pyx_kp_u_talib__common_pxi __pyx_string_tab[920]
+#define __pyx_kp_u_talib__func_pxi __pyx_string_tab[921]
+#define __pyx_kp_u_talib__stream_pxi __pyx_string_tab[922]
+#define __pyx_n_u_talib__ta_lib __pyx_string_tab[923]
+#define __pyx_n_u_test __pyx_string_tab[924]
+#define __pyx_n_u_threading __pyx_string_tab[925]
+#define __pyx_n_u_timeStamp __pyx_string_tab[926]
+#define __pyx_n_u_timeperiod __pyx_string_tab[927]
+#define __pyx_n_u_timeperiod1 __pyx_string_tab[928]
+#define __pyx_n_u_timeperiod2 __pyx_string_tab[929]
+#define __pyx_n_u_timeperiod3 __pyx_string_tab[930]
+#define __pyx_n_u_to_numpy __pyx_string_tab[931]
+#define __pyx_n_u_type __pyx_string_tab[932]
+#define __pyx_n_u_type_2 __pyx_string_tab[933]
+#define __pyx_n_u_unicode __pyx_string_tab[934]
+#define __pyx_n_u_update __pyx_string_tab[935]
+#define __pyx_n_u_update_info __pyx_string_tab[936]
+#define __pyx_n_u_upper __pyx_string_tab[937]
+#define __pyx_n_u_value __pyx_string_tab[938]
+#define __pyx_n_u_value_range __pyx_string_tab[939]
+#define __pyx_n_u_values __pyx_string_tab[940]
+#define __pyx_n_u_version __pyx_string_tab[941]
+#define __pyx_n_u_vfactor __pyx_string_tab[942]
+#define __pyx_n_u_volume __pyx_string_tab[943]
+#define __pyx_n_u_volume_data __pyx_string_tab[944]
+/* #### Code section: module_state_clear ### */
+#if CYTHON_USE_MODULE_STATE
+static CYTHON_SMALL_CODE int __pyx_m_clear(PyObject *m) {
+  __pyx_mstatetype *clear_module_state = __Pyx_PyModule_GetState(m);
+  if (!clear_module_state) return 0;
+  Py_CLEAR(clear_module_state->__pyx_d);
+  Py_CLEAR(clear_module_state->__pyx_b);
+  Py_CLEAR(clear_module_state->__pyx_cython_runtime);
+  Py_CLEAR(clear_module_state->__pyx_empty_tuple);
+  Py_CLEAR(clear_module_state->__pyx_empty_bytes);
+  Py_CLEAR(clear_module_state->__pyx_empty_unicode);
+  #ifdef __Pyx_CyFunction_USED
+  Py_CLEAR(clear_module_state->__pyx_CyFunctionType);
+  #endif
+  #ifdef __Pyx_FusedFunction_USED
+  Py_CLEAR(clear_module_state->__pyx_FusedFunctionType);
+  #endif
+  #if CYTHON_PEP489_MULTI_PHASE_INIT
+  __Pyx_State_RemoveModule(NULL);
+  #endif
+  Py_CLEAR(clear_module_state->__pyx_ptype_7cpython_4type_type);
+  Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_dtype);
+  Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_flatiter);
+  Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_broadcast);
+  Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_ndarray);
+  Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_generic);
+  Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_number);
+  Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_integer);
+  Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_signedinteger);
+  Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_unsignedinteger);
+  Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_inexact);
+  Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_floating);
+  Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_complexfloating);
+  Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_flexible);
+  Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_character);
+  Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_ufunc);
+  for (int i=0; i<10; ++i) { Py_CLEAR(clear_module_state->__pyx_tuple[i]); }
+  for (int i=0; i<369; ++i) { Py_CLEAR(clear_module_state->__pyx_codeobj_tab[i]); }
+  for (int i=0; i<945; ++i) { Py_CLEAR(clear_module_state->__pyx_string_tab[i]); }
+  Py_CLEAR(clear_module_state->__pyx_int_0);
+  Py_CLEAR(clear_module_state->__pyx_int_1);
+  Py_CLEAR(clear_module_state->__pyx_int_2);
+  Py_CLEAR(clear_module_state->__pyx_int_3);
+  Py_CLEAR(clear_module_state->__pyx_int_4);
+  Py_CLEAR(clear_module_state->__pyx_int_8);
+  Py_CLEAR(clear_module_state->__pyx_int_9);
+  Py_CLEAR(clear_module_state->__pyx_int_12);
+  Py_CLEAR(clear_module_state->__pyx_int_16);
+  Py_CLEAR(clear_module_state->__pyx_int_32);
+  Py_CLEAR(clear_module_state->__pyx_int_64);
+  Py_CLEAR(clear_module_state->__pyx_int_128);
+  Py_CLEAR(clear_module_state->__pyx_int_256);
+  Py_CLEAR(clear_module_state->__pyx_int_512);
+  Py_CLEAR(clear_module_state->__pyx_int_1024);
+  Py_CLEAR(clear_module_state->__pyx_int_2048);
+  Py_CLEAR(clear_module_state->__pyx_int_4096);
+  Py_CLEAR(clear_module_state->__pyx_int_16777216);
+  Py_CLEAR(clear_module_state->__pyx_int_67108864);
+  Py_CLEAR(clear_module_state->__pyx_int_134217728);
+  Py_CLEAR(clear_module_state->__pyx_int_268435456);
+  Py_CLEAR(clear_module_state->__pyx_int_neg_1);
+  return 0;
+}
+#endif
+/* #### Code section: module_state_traverse ### */
+#if CYTHON_USE_MODULE_STATE
+static CYTHON_SMALL_CODE int __pyx_m_traverse(PyObject *m, visitproc visit, void *arg) {
+  __pyx_mstatetype *traverse_module_state = __Pyx_PyModule_GetState(m);
+  if (!traverse_module_state) return 0;
+  Py_VISIT(traverse_module_state->__pyx_d);
+  Py_VISIT(traverse_module_state->__pyx_b);
+  Py_VISIT(traverse_module_state->__pyx_cython_runtime);
+  __Pyx_VISIT_CONST(traverse_module_state->__pyx_empty_tuple);
+  __Pyx_VISIT_CONST(traverse_module_state->__pyx_empty_bytes);
+  __Pyx_VISIT_CONST(traverse_module_state->__pyx_empty_unicode);
+  #ifdef __Pyx_CyFunction_USED
+  Py_VISIT(traverse_module_state->__pyx_CyFunctionType);
+  #endif
+  #ifdef __Pyx_FusedFunction_USED
+  Py_VISIT(traverse_module_state->__pyx_FusedFunctionType);
+  #endif
+  Py_VISIT(traverse_module_state->__pyx_ptype_7cpython_4type_type);
+  Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_dtype);
+  Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_flatiter);
+  Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_broadcast);
+  Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_ndarray);
+  Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_generic);
+  Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_number);
+  Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_integer);
+  Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_signedinteger);
+  Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_unsignedinteger);
+  Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_inexact);
+  Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_floating);
+  Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_complexfloating);
+  Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_flexible);
+  Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_character);
+  Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_ufunc);
+  for (int i=0; i<10; ++i) { __Pyx_VISIT_CONST(traverse_module_state->__pyx_tuple[i]); }
+  for (int i=0; i<369; ++i) { __Pyx_VISIT_CONST(traverse_module_state->__pyx_codeobj_tab[i]); }
+  for (int i=0; i<945; ++i) { __Pyx_VISIT_CONST(traverse_module_state->__pyx_string_tab[i]); }
+  __Pyx_VISIT_CONST(traverse_module_state->__pyx_int_0);
+  __Pyx_VISIT_CONST(traverse_module_state->__pyx_int_1);
+  __Pyx_VISIT_CONST(traverse_module_state->__pyx_int_2);
+  __Pyx_VISIT_CONST(traverse_module_state->__pyx_int_3);
+  __Pyx_VISIT_CONST(traverse_module_state->__pyx_int_4);
+  __Pyx_VISIT_CONST(traverse_module_state->__pyx_int_8);
+  __Pyx_VISIT_CONST(traverse_module_state->__pyx_int_9);
+  __Pyx_VISIT_CONST(traverse_module_state->__pyx_int_12);
+  __Pyx_VISIT_CONST(traverse_module_state->__pyx_int_16);
+  __Pyx_VISIT_CONST(traverse_module_state->__pyx_int_32);
+  __Pyx_VISIT_CONST(traverse_module_state->__pyx_int_64);
+  __Pyx_VISIT_CONST(traverse_module_state->__pyx_int_128);
+  __Pyx_VISIT_CONST(traverse_module_state->__pyx_int_256);
+  __Pyx_VISIT_CONST(traverse_module_state->__pyx_int_512);
+  __Pyx_VISIT_CONST(traverse_module_state->__pyx_int_1024);
+  __Pyx_VISIT_CONST(traverse_module_state->__pyx_int_2048);
+  __Pyx_VISIT_CONST(traverse_module_state->__pyx_int_4096);
+  __Pyx_VISIT_CONST(traverse_module_state->__pyx_int_16777216);
+  __Pyx_VISIT_CONST(traverse_module_state->__pyx_int_67108864);
+  __Pyx_VISIT_CONST(traverse_module_state->__pyx_int_134217728);
+  __Pyx_VISIT_CONST(traverse_module_state->__pyx_int_268435456);
+  __Pyx_VISIT_CONST(traverse_module_state->__pyx_int_neg_1);
+  return 0;
+}
+#endif
+/* #### Code section: module_code ### */
 
-    break;
-    case 3:
 
-    __Pyx_INCREF(__pyx_kp_s_Allocation_Error_TA_ALLOC_ERR);
-    __pyx_v_description = __pyx_kp_s_Allocation_Error_TA_ALLOC_ERR;
+static CYTHON_INLINE npy_intp __pyx_f_5numpy_5dtype_8itemsize_itemsize(PyArray_Descr *__pyx_v_self) {
+  npy_intp __pyx_r;
 
-    break;
-    case 4:
+  __pyx_r = PyDataType_ELSIZE(__pyx_v_self);
+  goto __pyx_L0;
 
-    __Pyx_INCREF(__pyx_kp_s_Group_Not_Found_TA_GROUP_NOT_FOU);
-    __pyx_v_description = __pyx_kp_s_Group_Not_Found_TA_GROUP_NOT_FOU;
 
-    break;
-    case 5:
+  /* function exit code */
+  __pyx_L0:;
+  return __pyx_r;
+}
 
-    __Pyx_INCREF(__pyx_kp_s_Function_Not_Found_TA_FUNC_NOT_F);
-    __pyx_v_description = __pyx_kp_s_Function_Not_Found_TA_FUNC_NOT_F;
 
-    break;
-    case 6:
+static CYTHON_INLINE npy_intp __pyx_f_5numpy_5dtype_9alignment_alignment(PyArray_Descr *__pyx_v_self) {
+  npy_intp __pyx_r;
 
-    __Pyx_INCREF(__pyx_kp_s_Invalid_Handle_TA_INVALID_HANDLE);
-    __pyx_v_description = __pyx_kp_s_Invalid_Handle_TA_INVALID_HANDLE;
+  __pyx_r = PyDataType_ALIGNMENT(__pyx_v_self);
+  goto __pyx_L0;
 
-    break;
-    case 7:
 
-    __Pyx_INCREF(__pyx_kp_s_Invalid_Parameter_Holder_TA_INVA);
-    __pyx_v_description = __pyx_kp_s_Invalid_Parameter_Holder_TA_INVA;
+  /* function exit code */
+  __pyx_L0:;
+  return __pyx_r;
+}
 
-    break;
-    case 8:
 
-    __Pyx_INCREF(__pyx_kp_s_Invalid_Parameter_Holder_Type_TA);
-    __pyx_v_description = __pyx_kp_s_Invalid_Parameter_Holder_Type_TA;
+static CYTHON_INLINE PyObject *__pyx_f_5numpy_5dtype_6fields_fields(PyArray_Descr *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1;
+  __Pyx_RefNannySetupContext("fields", 0);
 
-    break;
-    case 9:
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyDataType_FIELDS(__pyx_v_self);
+  __Pyx_INCREF(((PyObject *)__pyx_t_1));
+  __pyx_r = ((PyObject *)__pyx_t_1);
+  goto __pyx_L0;
 
-    __Pyx_INCREF(__pyx_kp_s_Invalid_Parameter_Function_TA_IN);
-    __pyx_v_description = __pyx_kp_s_Invalid_Parameter_Function_TA_IN;
 
-    break;
-    case 10:
+  /* function exit code */
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
 
-    __Pyx_INCREF(__pyx_kp_s_Input_Not_All_Initialized_TA_INP);
-    __pyx_v_description = __pyx_kp_s_Input_Not_All_Initialized_TA_INP;
 
-    break;
-    case 11:
+static CYTHON_INLINE PyObject *__pyx_f_5numpy_5dtype_5names_names(PyArray_Descr *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1;
+  __Pyx_RefNannySetupContext("names", 0);
 
-    __Pyx_INCREF(__pyx_kp_s_Output_Not_All_Initialized_TA_OU);
-    __pyx_v_description = __pyx_kp_s_Output_Not_All_Initialized_TA_OU;
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyDataType_NAMES(__pyx_v_self);
+  __Pyx_INCREF(((PyObject*)__pyx_t_1));
+  __pyx_r = ((PyObject*)__pyx_t_1);
+  goto __pyx_L0;
 
-    break;
-    case 12:
 
-    __Pyx_INCREF(__pyx_kp_s_Out_of_Range_Start_Index_TA_OUT);
-    __pyx_v_description = __pyx_kp_s_Out_of_Range_Start_Index_TA_OUT;
+  /* function exit code */
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
 
-    break;
-    case 13:
 
-    __Pyx_INCREF(__pyx_kp_s_Out_of_Range_End_Index_TA_OUT_OF);
-    __pyx_v_description = __pyx_kp_s_Out_of_Range_End_Index_TA_OUT_OF;
+static CYTHON_INLINE PyArray_ArrayDescr *__pyx_f_5numpy_5dtype_8subarray_subarray(PyArray_Descr *__pyx_v_self) {
+  PyArray_ArrayDescr *__pyx_r;
 
-    break;
-    case 14:
+  __pyx_r = PyDataType_SUBARRAY(__pyx_v_self);
+  goto __pyx_L0;
 
-    __Pyx_INCREF(__pyx_kp_s_Invalid_List_Type_TA_INVALID_LIS);
-    __pyx_v_description = __pyx_kp_s_Invalid_List_Type_TA_INVALID_LIS;
 
-    break;
-    case 15:
+  /* function exit code */
+  __pyx_L0:;
+  return __pyx_r;
+}
 
-    __Pyx_INCREF(__pyx_kp_s_Bad_Object_TA_BAD_OBJECT);
-    __pyx_v_description = __pyx_kp_s_Bad_Object_TA_BAD_OBJECT;
 
-    break;
-    case 16:
+static CYTHON_INLINE npy_uint64 __pyx_f_5numpy_5dtype_5flags_flags(PyArray_Descr *__pyx_v_self) {
+  npy_uint64 __pyx_r;
 
-    __Pyx_INCREF(__pyx_kp_s_Not_Supported_TA_NOT_SUPPORTED);
-    __pyx_v_description = __pyx_kp_s_Not_Supported_TA_NOT_SUPPORTED;
+  __pyx_r = PyDataType_FLAGS(__pyx_v_self);
+  goto __pyx_L0;
 
-    break;
-    case 0x1388:
 
-    __Pyx_INCREF(__pyx_kp_s_Internal_Error_TA_INTERNAL_ERROR);
-    __pyx_v_description = __pyx_kp_s_Internal_Error_TA_INTERNAL_ERROR;
+  /* function exit code */
+  __pyx_L0:;
+  return __pyx_r;
+}
 
-    break;
-    case 0xFFFF:
 
-    __Pyx_INCREF(__pyx_kp_s_Unknown_Error_TA_UNKNOWN_ERR);
-    __pyx_v_description = __pyx_kp_s_Unknown_Error_TA_UNKNOWN_ERR;
+static CYTHON_INLINE int __pyx_f_5numpy_9broadcast_7numiter_numiter(PyArrayMultiIterObject *__pyx_v_self) {
+  int __pyx_r;
 
-    break;
-    default:
+  __pyx_r = PyArray_MultiIter_NUMITER(__pyx_v_self);
+  goto __pyx_L0;
 
-    __Pyx_INCREF(__pyx_kp_s_Unknown_Error);
-    __pyx_v_description = __pyx_kp_s_Unknown_Error;
-    break;
-  }
 
-  __pyx_t_1 = __Pyx_PyInt_From_TA_RetCode(__pyx_v_ret_code); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 48, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = PyTuple_New(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 48, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_INCREF(__pyx_v_function_name);
-  __Pyx_GIVEREF(__pyx_v_function_name);
-  PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_function_name);
-  __Pyx_GIVEREF(__pyx_t_1);
-  PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_1);
-  __Pyx_INCREF(__pyx_v_description);
-  __Pyx_GIVEREF(__pyx_v_description);
-  PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_v_description);
-  __pyx_t_1 = 0;
+  /* function exit code */
+  __pyx_L0:;
+  return __pyx_r;
+}
 
-  __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_s_function_failed_with_error_co, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 47, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __pyx_t_2 = __Pyx_PyObject_CallOneArg(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 47, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __Pyx_Raise(__pyx_t_2, 0, 0, 0);
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __PYX_ERR(0, 47, __pyx_L1_error)
+
+static CYTHON_INLINE npy_intp __pyx_f_5numpy_9broadcast_4size_size(PyArrayMultiIterObject *__pyx_v_self) {
+  npy_intp __pyx_r;
+
+  __pyx_r = PyArray_MultiIter_SIZE(__pyx_v_self);
+  goto __pyx_L0;
 
 
   /* function exit code */
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_XDECREF(__pyx_t_2);
-  __Pyx_AddTraceback("talib._ta_lib._ta_check_success", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = 0;
   __pyx_L0:;
-  __Pyx_XDECREF(__pyx_v_description);
-  __Pyx_XGIVEREF(__pyx_r);
-  __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-/* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_1_ta_check_success(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static PyObject *__pyx_pw_5talib_7_ta_lib_1_ta_check_success(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyObject *__pyx_v_function_name = 0;
-  TA_RetCode __pyx_v_ret_code;
-  PyObject *__pyx_r = 0;
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("_ta_check_success (wrapper)", 0);
-  {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_function_name,&__pyx_n_s_ret_code,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);
-        CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-        CYTHON_FALLTHROUGH;
-        case  0: break;
-        default: goto __pyx_L5_argtuple_error;
-      }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_function_name)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_ret_code)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("_ta_check_success", 1, 2, 2, 1); __PYX_ERR(0, 6, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "_ta_check_success") < 0)) __PYX_ERR(0, 6, __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_function_name = ((PyObject*)values[0]);
-    __pyx_v_ret_code = __Pyx_PyInt_As_TA_RetCode(values[1]); if (unlikely((__pyx_v_ret_code == ((TA_RetCode)-1)) && PyErr_Occurred())) __PYX_ERR(0, 6, __pyx_L3_error)
-  }
-  goto __pyx_L4_argument_unpacking_done;
-  __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("_ta_check_success", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 6, __pyx_L3_error)
-  __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib._ta_check_success", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __Pyx_RefNannyFinishContext();
-  return NULL;
-  __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_function_name), (&PyString_Type), 1, "function_name", 1))) __PYX_ERR(0, 6, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib__ta_check_success(__pyx_self, __pyx_v_function_name, __pyx_v_ret_code);
 
-  /* function exit code */
+static CYTHON_INLINE npy_intp __pyx_f_5numpy_9broadcast_5index_index(PyArrayMultiIterObject *__pyx_v_self) {
+  npy_intp __pyx_r;
+
+  __pyx_r = PyArray_MultiIter_INDEX(__pyx_v_self);
   goto __pyx_L0;
-  __pyx_L1_error:;
-  __pyx_r = NULL;
+
+
+  /* function exit code */
   __pyx_L0:;
-  __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib__ta_check_success(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_function_name, TA_RetCode __pyx_v_ret_code) {
-  PyObject *__pyx_r = NULL;
-  __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
-  __Pyx_RefNannySetupContext("_ta_check_success", 0);
-  __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_v_function_name, __pyx_v_ret_code, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_r = __pyx_t_1;
-  __pyx_t_1 = 0;
+
+static CYTHON_INLINE int __pyx_f_5numpy_9broadcast_2nd_nd(PyArrayMultiIterObject *__pyx_v_self) {
+  int __pyx_r;
+
+  __pyx_r = PyArray_MultiIter_NDIM(__pyx_v_self);
   goto __pyx_L0;
 
+
   /* function exit code */
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib._ta_check_success", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XGIVEREF(__pyx_r);
-  __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
 
-/* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_3_ta_initialize(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused); /*proto*/
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_3_ta_initialize = {"_ta_initialize", (PyCFunction)__pyx_pw_5talib_7_ta_lib_3_ta_initialize, METH_NOARGS, 0};
-static PyObject *__pyx_pw_5talib_7_ta_lib_3_ta_initialize(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused) {
-  PyObject *__pyx_r = 0;
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("_ta_initialize (wrapper)", 0);
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_2_ta_initialize(__pyx_self);
+static CYTHON_INLINE npy_intp *__pyx_f_5numpy_9broadcast_10dimensions_dimensions(PyArrayMultiIterObject *__pyx_v_self) {
+  npy_intp *__pyx_r;
+
+  __pyx_r = PyArray_MultiIter_DIMS(__pyx_v_self);
+  goto __pyx_L0;
+
 
   /* function exit code */
-  __Pyx_RefNannyFinishContext();
+  __pyx_L0:;
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_2_ta_initialize(CYTHON_UNUSED PyObject *__pyx_self) {
-  TA_RetCode __pyx_v_ret_code;
-  PyObject *__pyx_r = NULL;
-  __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
-  __Pyx_RefNannySetupContext("_ta_initialize", 0);
 
-  __pyx_v_ret_code = TA_Initialize();
+static CYTHON_INLINE void **__pyx_f_5numpy_9broadcast_5iters_iters(PyArrayMultiIterObject *__pyx_v_self) {
+  void **__pyx_r;
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_Initialize, __pyx_v_ret_code, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 53, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_r = PyArray_MultiIter_ITERS(__pyx_v_self);
+  goto __pyx_L0;
 
 
   /* function exit code */
-  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __pyx_L0:;
+  return __pyx_r;
+}
+
+
+static CYTHON_INLINE PyObject *__pyx_f_5numpy_7ndarray_4base_base(PyArrayObject *__pyx_v_self) {
+  PyObject *__pyx_r;
+
+  __pyx_r = PyArray_BASE(__pyx_v_self);
   goto __pyx_L0;
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib._ta_initialize", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = NULL;
+
+
+  /* function exit code */
   __pyx_L0:;
-  __Pyx_XGIVEREF(__pyx_r);
-  __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
 
-/* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_5_ta_shutdown(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused); /*proto*/
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_5_ta_shutdown = {"_ta_shutdown", (PyCFunction)__pyx_pw_5talib_7_ta_lib_5_ta_shutdown, METH_NOARGS, 0};
-static PyObject *__pyx_pw_5talib_7_ta_lib_5_ta_shutdown(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused) {
-  PyObject *__pyx_r = 0;
+static CYTHON_INLINE PyArray_Descr *__pyx_f_5numpy_7ndarray_5descr_descr(PyArrayObject *__pyx_v_self) {
+  PyArray_Descr *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("_ta_shutdown (wrapper)", 0);
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_4_ta_shutdown(__pyx_self);
+  PyArray_Descr *__pyx_t_1;
+  __Pyx_RefNannySetupContext("descr", 0);
+
+  __Pyx_XDECREF((PyObject *)__pyx_r);
+  __pyx_t_1 = PyArray_DESCR(__pyx_v_self);
+  __Pyx_INCREF((PyObject *)((PyArray_Descr *)__pyx_t_1));
+  __pyx_r = ((PyArray_Descr *)__pyx_t_1);
+  goto __pyx_L0;
+
 
   /* function exit code */
+  __pyx_L0:;
+  __Pyx_XGIVEREF((PyObject *)__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_4_ta_shutdown(CYTHON_UNUSED PyObject *__pyx_self) {
-  TA_RetCode __pyx_v_ret_code;
-  PyObject *__pyx_r = NULL;
-  __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
-  __Pyx_RefNannySetupContext("_ta_shutdown", 0);
 
-  __pyx_v_ret_code = TA_Shutdown();
+static CYTHON_INLINE int __pyx_f_5numpy_7ndarray_4ndim_ndim(PyArrayObject *__pyx_v_self) {
+  int __pyx_r;
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_Shutdown, __pyx_v_ret_code, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 58, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_r = PyArray_NDIM(__pyx_v_self);
+  goto __pyx_L0;
 
 
   /* function exit code */
-  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
-  goto __pyx_L0;
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib._ta_shutdown", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XGIVEREF(__pyx_r);
-  __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
 
-/* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_7MA_Type_1__init__(PyObject *__pyx_self, PyObject *__pyx_v_self); /*proto*/
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_7MA_Type_1__init__ = {"__init__", (PyCFunction)__pyx_pw_5talib_7_ta_lib_7MA_Type_1__init__, METH_O, 0};
-static PyObject *__pyx_pw_5talib_7_ta_lib_7MA_Type_1__init__(PyObject *__pyx_self, PyObject *__pyx_v_self) {
-  PyObject *__pyx_r = 0;
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__init__ (wrapper)", 0);
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_7MA_Type___init__(__pyx_self, ((PyObject *)__pyx_v_self));
+static CYTHON_INLINE npy_intp *__pyx_f_5numpy_7ndarray_5shape_shape(PyArrayObject *__pyx_v_self) {
+  npy_intp *__pyx_r;
+
+  __pyx_r = PyArray_DIMS(__pyx_v_self);
+  goto __pyx_L0;
+
 
   /* function exit code */
-  __Pyx_RefNannyFinishContext();
+  __pyx_L0:;
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_7MA_Type___init__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
-  PyObject *__pyx_r = NULL;
-  __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
-  PyObject *__pyx_t_2 = NULL;
-  PyObject *__pyx_t_3 = NULL;
-  __Pyx_RefNannySetupContext("__init__", 0);
 
-  __pyx_t_1 = __Pyx_PyDict_NewPresized(9); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 65, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_MA_Type); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 65, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_SMA); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 65, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  if (PyDict_SetItem(__pyx_t_1, __pyx_t_3, __pyx_kp_s_Simple_Moving_Average) < 0) __PYX_ERR(0, 65, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+static CYTHON_INLINE npy_intp *__pyx_f_5numpy_7ndarray_7strides_strides(PyArrayObject *__pyx_v_self) {
+  npy_intp *__pyx_r;
 
-  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_MA_Type); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 66, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_EMA); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 66, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  if (PyDict_SetItem(__pyx_t_1, __pyx_t_2, __pyx_kp_s_Exponential_Moving_Average) < 0) __PYX_ERR(0, 65, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_r = PyArray_STRIDES(__pyx_v_self);
+  goto __pyx_L0;
 
-  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_MA_Type); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 67, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_WMA); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 67, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  if (PyDict_SetItem(__pyx_t_1, __pyx_t_3, __pyx_kp_s_Weighted_Moving_Average) < 0) __PYX_ERR(0, 65, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
-  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_MA_Type); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 68, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_DEMA); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 68, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  if (PyDict_SetItem(__pyx_t_1, __pyx_t_2, __pyx_kp_s_Double_Exponential_Moving_Averag) < 0) __PYX_ERR(0, 65, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  /* function exit code */
+  __pyx_L0:;
+  return __pyx_r;
+}
 
-  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_MA_Type); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 69, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_TEMA); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 69, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  if (PyDict_SetItem(__pyx_t_1, __pyx_t_3, __pyx_kp_s_Triple_Exponential_Moving_Averag) < 0) __PYX_ERR(0, 65, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
-  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_MA_Type); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 70, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_TRIMA); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 70, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  if (PyDict_SetItem(__pyx_t_1, __pyx_t_2, __pyx_kp_s_Triangular_Moving_Average) < 0) __PYX_ERR(0, 65, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+static CYTHON_INLINE npy_intp __pyx_f_5numpy_7ndarray_4size_size(PyArrayObject *__pyx_v_self) {
+  npy_intp __pyx_r;
 
-  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_MA_Type); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 71, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_KAMA); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 71, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  if (PyDict_SetItem(__pyx_t_1, __pyx_t_3, __pyx_kp_s_Kaufman_Adaptive_Moving_Average) < 0) __PYX_ERR(0, 65, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_r = PyArray_SIZE(__pyx_v_self);
+  goto __pyx_L0;
 
-  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_MA_Type); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 72, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_MAMA); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 72, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  if (PyDict_SetItem(__pyx_t_1, __pyx_t_2, __pyx_kp_s_MESA_Adaptive_Moving_Average) < 0) __PYX_ERR(0, 65, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_MA_Type); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 73, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_T3); 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;
-  if (PyDict_SetItem(__pyx_t_1, __pyx_t_3, __pyx_kp_s_Triple_Generalized_Double_Expone) < 0) __PYX_ERR(0, 65, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  /* function exit code */
+  __pyx_L0:;
+  return __pyx_r;
+}
 
-  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_lookup, __pyx_t_1) < 0) __PYX_ERR(0, 64, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
+static CYTHON_INLINE char *__pyx_f_5numpy_7ndarray_4data_data(PyArrayObject *__pyx_v_self) {
+  char *__pyx_r;
 
-  /* function exit code */
-  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __pyx_r = PyArray_BYTES(__pyx_v_self);
   goto __pyx_L0;
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_XDECREF(__pyx_t_2);
-  __Pyx_XDECREF(__pyx_t_3);
-  __Pyx_AddTraceback("talib._ta_lib.MA_Type.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = NULL;
+
+
+  /* function exit code */
   __pyx_L0:;
-  __Pyx_XGIVEREF(__pyx_r);
-  __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
 
-/* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_7MA_Type_3__getitem__(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_7MA_Type_3__getitem__ = {"__getitem__", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_7MA_Type_3__getitem__, METH_VARARGS|METH_KEYWORDS, 0};
-static PyObject *__pyx_pw_5talib_7_ta_lib_7MA_Type_3__getitem__(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyObject *__pyx_v_self = 0;
-  PyObject *__pyx_v_type_ = 0;
-  PyObject *__pyx_r = 0;
+static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew1(PyObject *__pyx_v_a) {
+  PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__getitem__ (wrapper)", 0);
-  {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self,&__pyx_n_s_type,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);
-        CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-        CYTHON_FALLTHROUGH;
-        case  0: break;
-        default: goto __pyx_L5_argtuple_error;
-      }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_self)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_type)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("__getitem__", 1, 2, 2, 1); __PYX_ERR(0, 76, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__getitem__") < 0)) __PYX_ERR(0, 76, __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_self = values[0];
-    __pyx_v_type_ = values[1];
-  }
-  goto __pyx_L4_argument_unpacking_done;
-  __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("__getitem__", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 76, __pyx_L3_error)
-  __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.MA_Type.__getitem__", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __Pyx_RefNannyFinishContext();
-  return NULL;
-  __pyx_L4_argument_unpacking_done:;
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_7MA_Type_2__getitem__(__pyx_self, __pyx_v_self, __pyx_v_type_);
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("PyArray_MultiIterNew1", 0);
+
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyArray_MultiIterNew(1, ((void *)__pyx_v_a)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 824, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
 
   /* 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;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_7MA_Type_2__getitem__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_type_) {
+
+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;
-  PyObject *__pyx_t_2 = NULL;
-  __Pyx_RefNannySetupContext("__getitem__", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("PyArray_MultiIterNew2", 0);
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_lookup); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 77, __pyx_L1_error)
+  __pyx_t_1 = PyArray_MultiIterNew(2, ((void *)__pyx_v_a), ((void *)__pyx_v_b)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 827, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = __Pyx_PyObject_GetItem(__pyx_t_1, __pyx_v_type_); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 77, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_r = __pyx_t_2;
-  __pyx_t_2 = 0;
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
   goto __pyx_L0;
 
 
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_XDECREF(__pyx_t_2);
-  __Pyx_AddTraceback("talib._ta_lib.MA_Type.__getitem__", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = NULL;
+  __Pyx_AddTraceback("numpy.PyArray_MultiIterNew2", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
   __pyx_L0:;
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
@@ -5295,104 +5913,57 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_7MA_Type_2__getitem__(CYTHON_UNUSED Py
 }
 
 
-/* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_7_ta_set_unstable_period(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_7_ta_set_unstable_period = {"_ta_set_unstable_period", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_7_ta_set_unstable_period, METH_VARARGS|METH_KEYWORDS, 0};
-static PyObject *__pyx_pw_5talib_7_ta_lib_7_ta_set_unstable_period(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyObject *__pyx_v_name = 0;
-  PyObject *__pyx_v_period = 0;
-  PyObject *__pyx_r = 0;
+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
-  __Pyx_RefNannySetupContext("_ta_set_unstable_period (wrapper)", 0);
-  {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_name,&__pyx_n_s_period,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);
-        CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-        CYTHON_FALLTHROUGH;
-        case  0: break;
-        default: goto __pyx_L5_argtuple_error;
-      }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_name)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_period)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("_ta_set_unstable_period", 1, 2, 2, 1); __PYX_ERR(0, 90, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "_ta_set_unstable_period") < 0)) __PYX_ERR(0, 90, __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_name = values[0];
-    __pyx_v_period = values[1];
-  }
-  goto __pyx_L4_argument_unpacking_done;
-  __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("_ta_set_unstable_period", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 90, __pyx_L3_error)
-  __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib._ta_set_unstable_period", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __Pyx_RefNannyFinishContext();
-  return NULL;
-  __pyx_L4_argument_unpacking_done:;
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_6_ta_set_unstable_period(__pyx_self, __pyx_v_name, __pyx_v_period);
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("PyArray_MultiIterNew3", 0);
+
+  __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(3, 830, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
 
   /* 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;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_6_ta_set_unstable_period(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_name, PyObject *__pyx_v_period) {
-  TA_RetCode __pyx_v_ret_code;
-  TA_FuncUnstId __pyx_v_id;
+
+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;
-  PyObject *__pyx_t_2 = NULL;
-  TA_FuncUnstId __pyx_t_3;
-  unsigned int __pyx_t_4;
-  __Pyx_RefNannySetupContext("_ta_set_unstable_period", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("PyArray_MultiIterNew4", 0);
 
-  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_ta_func_unst_ids); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 92, __pyx_L1_error)
+  __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(3, 833, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = __Pyx_PyObject_GetItem(__pyx_t_1, __pyx_v_name); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 92, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_3 = __Pyx_PyInt_As_TA_FuncUnstId(__pyx_t_2); if (unlikely((__pyx_t_3 == ((TA_FuncUnstId)-1)) && PyErr_Occurred())) __PYX_ERR(0, 92, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __pyx_v_id = __pyx_t_3;
-
-  __pyx_t_4 = __Pyx_PyInt_As_unsigned_int(__pyx_v_period); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(0, 93, __pyx_L1_error)
-  __pyx_v_ret_code = TA_SetUnstablePeriod(__pyx_v_id, __pyx_t_4);
-
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_SetUnstablePeriod, __pyx_v_ret_code, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 94, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
 
 
   /* function exit code */
-  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
-  goto __pyx_L0;
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_XDECREF(__pyx_t_2);
-  __Pyx_AddTraceback("talib._ta_lib._ta_set_unstable_period", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = NULL;
+  __Pyx_AddTraceback("numpy.PyArray_MultiIterNew4", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
   __pyx_L0:;
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
@@ -5400,55 +5971,28 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_6_ta_set_unstable_period(CYTHON_UNUSED
 }
 
 
-/* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_9_ta_get_unstable_period(PyObject *__pyx_self, PyObject *__pyx_v_name); /*proto*/
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_9_ta_get_unstable_period = {"_ta_get_unstable_period", (PyCFunction)__pyx_pw_5talib_7_ta_lib_9_ta_get_unstable_period, METH_O, 0};
-static PyObject *__pyx_pw_5talib_7_ta_lib_9_ta_get_unstable_period(PyObject *__pyx_self, PyObject *__pyx_v_name) {
-  PyObject *__pyx_r = 0;
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("_ta_get_unstable_period (wrapper)", 0);
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_8_ta_get_unstable_period(__pyx_self, ((PyObject *)__pyx_v_name));
-
-  /* function exit code */
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-static PyObject *__pyx_pf_5talib_7_ta_lib_8_ta_get_unstable_period(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_name) {
-  unsigned int __pyx_v_period;
-  TA_FuncUnstId __pyx_v_id;
+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;
-  PyObject *__pyx_t_2 = NULL;
-  TA_FuncUnstId __pyx_t_3;
-  __Pyx_RefNannySetupContext("_ta_get_unstable_period", 0);
-
-  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_ta_func_unst_ids); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 98, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = __Pyx_PyObject_GetItem(__pyx_t_1, __pyx_v_name); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 98, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_3 = __Pyx_PyInt_As_TA_FuncUnstId(__pyx_t_2); if (unlikely((__pyx_t_3 == ((TA_FuncUnstId)-1)) && PyErr_Occurred())) __PYX_ERR(0, 98, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __pyx_v_id = __pyx_t_3;
-
-  __pyx_v_period = TA_GetUnstablePeriod(__pyx_v_id);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("PyArray_MultiIterNew5", 0);
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_2 = __Pyx_PyInt_From_unsigned_int(__pyx_v_period); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 100, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_r = __pyx_t_2;
-  __pyx_t_2 = 0;
+  __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(3, 836, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
   goto __pyx_L0;
 
 
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_XDECREF(__pyx_t_2);
-  __Pyx_AddTraceback("talib._ta_lib._ta_get_unstable_period", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = NULL;
+  __Pyx_AddTraceback("numpy.PyArray_MultiIterNew5", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
   __pyx_L0:;
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
@@ -5456,43 +6000,33 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8_ta_get_unstable_period(CYTHON_UNUSED
 }
 
 
-/* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_11_ta_set_compatibility(PyObject *__pyx_self, PyObject *__pyx_v_value); /*proto*/
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_11_ta_set_compatibility = {"_ta_set_compatibility", (PyCFunction)__pyx_pw_5talib_7_ta_lib_11_ta_set_compatibility, METH_O, 0};
-static PyObject *__pyx_pw_5talib_7_ta_lib_11_ta_set_compatibility(PyObject *__pyx_self, PyObject *__pyx_v_value) {
-  PyObject *__pyx_r = 0;
+static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyDataType_SHAPE(PyArray_Descr *__pyx_v_d) {
+  PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("_ta_set_compatibility (wrapper)", 0);
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_10_ta_set_compatibility(__pyx_self, ((PyObject *)__pyx_v_value));
+  int __pyx_t_1;
+  PyObject *__pyx_t_2;
+  __Pyx_RefNannySetupContext("PyDataType_SHAPE", 0);
 
-  /* function exit code */
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
+  __pyx_t_1 = PyDataType_HASSUBARRAY(__pyx_v_d);
+  if (__pyx_t_1) {
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_10_ta_set_compatibility(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_value) {
-  TA_RetCode __pyx_v_ret_code;
-  PyObject *__pyx_r = NULL;
-  __Pyx_RefNannyDeclarations
-  TA_Compatibility __pyx_t_1;
-  PyObject *__pyx_t_2 = NULL;
-  __Pyx_RefNannySetupContext("_ta_set_compatibility", 0);
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_t_2 = __pyx_f_5numpy_5dtype_8subarray_subarray(__pyx_v_d)->shape;
+    __Pyx_INCREF(((PyObject*)__pyx_t_2));
+    __pyx_r = ((PyObject*)__pyx_t_2);
+    goto __pyx_L0;
 
-  __pyx_t_1 = __Pyx_PyInt_As_TA_Compatibility(__pyx_v_value); if (unlikely((__pyx_t_1 == ((TA_Compatibility)-1)) && PyErr_Occurred())) __PYX_ERR(0, 104, __pyx_L1_error)
-  __pyx_v_ret_code = TA_SetCompatibility(__pyx_t_1);
+  }
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_SetCompatibility, __pyx_v_ret_code, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 105, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  /*else*/ {
+    __Pyx_XDECREF(__pyx_r);
+    __Pyx_INCREF(__pyx_mstate_global->__pyx_empty_tuple);
+    __pyx_r = __pyx_mstate_global->__pyx_empty_tuple;
+    goto __pyx_L0;
+  }
 
 
   /* function exit code */
-  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
-  goto __pyx_L0;
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_2);
-  __Pyx_AddTraceback("talib._ta_lib._ta_set_compatibility", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
@@ -5500,42 +6034,50 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_10_ta_set_compatibility(CYTHON_UNUSED
 }
 
 
-/* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_13_ta_get_compatibility(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused); /*proto*/
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_13_ta_get_compatibility = {"_ta_get_compatibility", (PyCFunction)__pyx_pw_5talib_7_ta_lib_13_ta_get_compatibility, METH_NOARGS, 0};
-static PyObject *__pyx_pw_5talib_7_ta_lib_13_ta_get_compatibility(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused) {
-  PyObject *__pyx_r = 0;
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("_ta_get_compatibility (wrapper)", 0);
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_12_ta_get_compatibility(__pyx_self);
+static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_arr, PyObject *__pyx_v_base) {
+  int __pyx_t_1;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+
+  Py_INCREF(__pyx_v_base);
+
+  __pyx_t_1 = PyArray_SetBaseObject(__pyx_v_arr, __pyx_v_base); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(3, 1028, __pyx_L1_error)
+
 
   /* function exit code */
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_AddTraceback("numpy.set_array_base", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_L0:;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_12_ta_get_compatibility(CYTHON_UNUSED PyObject *__pyx_self) {
-  int __pyx_v_value;
+
+static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__pyx_v_arr) {
+  PyObject *__pyx_v_base;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
-  __Pyx_RefNannySetupContext("_ta_get_compatibility", 0);
+  int __pyx_t_1;
+  __Pyx_RefNannySetupContext("get_array_base", 0);
 
-  __pyx_v_value = TA_GetCompatibility();
+  __pyx_v_base = PyArray_BASE(__pyx_v_arr);
+
+  __pyx_t_1 = (__pyx_v_base == NULL);
+  if (__pyx_t_1) {
+
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+    goto __pyx_L0;
+
+  }
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_value); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 110, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_r = __pyx_t_1;
-  __pyx_t_1 = 0;
+  __Pyx_INCREF(((PyObject *)__pyx_v_base));
+  __pyx_r = ((PyObject *)__pyx_v_base);
   goto __pyx_L0;
 
 
   /* function exit code */
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib._ta_get_compatibility", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
@@ -5543,789 +6085,767 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_12_ta_get_compatibility(CYTHON_UNUSED
 }
 
 
-/* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_15_ta_set_candle_settings(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_15_ta_set_candle_settings = {"_ta_set_candle_settings", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_15_ta_set_candle_settings, METH_VARARGS|METH_KEYWORDS, 0};
-static PyObject *__pyx_pw_5talib_7_ta_lib_15_ta_set_candle_settings(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyObject *__pyx_v_settingtype = 0;
-  PyObject *__pyx_v_rangetype = 0;
-  PyObject *__pyx_v_avgperiod = 0;
-  PyObject *__pyx_v_factor = 0;
-  PyObject *__pyx_r = 0;
+static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) {
+  int __pyx_r;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("_ta_set_candle_settings (wrapper)", 0);
+  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;
+  PyObject *__pyx_t_9 = NULL;
+  PyObject *__pyx_t_10 = NULL;
+  size_t __pyx_t_11;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("import_array", 0);
+
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_settingtype,&__pyx_n_s_rangetype,&__pyx_n_s_avgperiod,&__pyx_n_s_factor,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-        CYTHON_FALLTHROUGH;
-        case  0: break;
-        default: goto __pyx_L5_argtuple_error;
-      }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_settingtype)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_rangetype)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("_ta_set_candle_settings", 1, 4, 4, 1); __PYX_ERR(0, 124, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_avgperiod)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("_ta_set_candle_settings", 1, 4, 4, 2); __PYX_ERR(0, 124, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_factor)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("_ta_set_candle_settings", 1, 4, 4, 3); __PYX_ERR(0, 124, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "_ta_set_candle_settings") < 0)) __PYX_ERR(0, 124, __pyx_L3_error)
-      }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
-      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);
-    }
-    __pyx_v_settingtype = values[0];
-    __pyx_v_rangetype = values[1];
-    __pyx_v_avgperiod = values[2];
-    __pyx_v_factor = values[3];
-  }
-  goto __pyx_L4_argument_unpacking_done;
-  __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("_ta_set_candle_settings", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 124, __pyx_L3_error)
-  __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib._ta_set_candle_settings", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __Pyx_RefNannyFinishContext();
-  return NULL;
-  __pyx_L4_argument_unpacking_done:;
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_14_ta_set_candle_settings(__pyx_self, __pyx_v_settingtype, __pyx_v_rangetype, __pyx_v_avgperiod, __pyx_v_factor);
+    __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:*/ {
 
-  /* function exit code */
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
+      __pyx_t_4 = _import_array(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(3, 1040, __pyx_L3_error)
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_14_ta_set_candle_settings(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_settingtype, PyObject *__pyx_v_rangetype, PyObject *__pyx_v_avgperiod, PyObject *__pyx_v_factor) {
-  TA_RetCode __pyx_v_ret_code;
-  PyObject *__pyx_r = NULL;
-  __Pyx_RefNannyDeclarations
-  TA_CandleSettingType __pyx_t_1;
-  TA_RangeType __pyx_t_2;
-  int __pyx_t_3;
-  double __pyx_t_4;
-  PyObject *__pyx_t_5 = NULL;
-  __Pyx_RefNannySetupContext("_ta_set_candle_settings", 0);
+    }
+    __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_L8_try_end;
+    __pyx_L3_error:;
 
-  __pyx_t_1 = __Pyx_PyInt_As_TA_CandleSettingType(__pyx_v_settingtype); if (unlikely((__pyx_t_1 == ((TA_CandleSettingType)-1)) && PyErr_Occurred())) __PYX_ERR(0, 126, __pyx_L1_error)
-  __pyx_t_2 = __Pyx_PyInt_As_TA_RangeType(__pyx_v_rangetype); if (unlikely((__pyx_t_2 == ((TA_RangeType)-1)) && PyErr_Occurred())) __PYX_ERR(0, 126, __pyx_L1_error)
-  __pyx_t_3 = __Pyx_PyInt_As_int(__pyx_v_avgperiod); if (unlikely((__pyx_t_3 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 126, __pyx_L1_error)
-  __pyx_t_4 = __pyx_PyFloat_AsDouble(__pyx_v_factor); if (unlikely((__pyx_t_4 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 126, __pyx_L1_error)
-  __pyx_v_ret_code = TA_SetCandleSettings(__pyx_t_1, __pyx_t_2, __pyx_t_3, __pyx_t_4);
+    __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(((PyTypeObject*)PyExc_Exception))));
+    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(3, 1041, __pyx_L5_except_error)
+      __Pyx_XGOTREF(__pyx_t_5);
+      __Pyx_XGOTREF(__pyx_t_6);
+      __Pyx_XGOTREF(__pyx_t_7);
 
-  __pyx_t_5 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_SetCandleSettings, __pyx_v_ret_code, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 127, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_5);
-  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __pyx_t_9 = NULL;
+      __Pyx_INCREF(__pyx_builtin_ImportError);
+      __pyx_t_10 = __pyx_builtin_ImportError; 
+      __pyx_t_11 = 1;
+      {
+        PyObject *__pyx_callargs[2] = {__pyx_t_9, __pyx_mstate_global->__pyx_kp_u_numpy__core_multiarray_failed_to};
+        __pyx_t_8 = __Pyx_PyObject_FastCall(__pyx_t_10, __pyx_callargs+__pyx_t_11, (2-__pyx_t_11) | (__pyx_t_11*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+        __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+        __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+        if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 1042, __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(3, 1042, __pyx_L5_except_error)
+    }
+    goto __pyx_L5_except_error;
+
+    __pyx_L5_except_error:;
+    __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_L8_try_end:;
+  }
 
 
   /* function exit code */
-  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __pyx_r = 0;
   goto __pyx_L0;
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_5);
-  __Pyx_AddTraceback("talib._ta_lib._ta_set_candle_settings", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = NULL;
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_XDECREF(__pyx_t_9);
+  __Pyx_XDECREF(__pyx_t_10);
+  __Pyx_AddTraceback("numpy.import_array", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1;
   __pyx_L0:;
-  __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
 
-/* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_17_ta_restore_candle_default_settings(PyObject *__pyx_self, PyObject *__pyx_v_settingtype); /*proto*/
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_17_ta_restore_candle_default_settings = {"_ta_restore_candle_default_settings", (PyCFunction)__pyx_pw_5talib_7_ta_lib_17_ta_restore_candle_default_settings, METH_O, 0};
-static PyObject *__pyx_pw_5talib_7_ta_lib_17_ta_restore_candle_default_settings(PyObject *__pyx_self, PyObject *__pyx_v_settingtype) {
-  PyObject *__pyx_r = 0;
+static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) {
+  int __pyx_r;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("_ta_restore_candle_default_settings (wrapper)", 0);
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_16_ta_restore_candle_default_settings(__pyx_self, ((PyObject *)__pyx_v_settingtype));
+  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;
+  PyObject *__pyx_t_9 = NULL;
+  PyObject *__pyx_t_10 = NULL;
+  size_t __pyx_t_11;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("import_umath", 0);
 
-  /* function exit code */
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
+  {
+    __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:*/ {
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_16_ta_restore_candle_default_settings(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_settingtype) {
-  TA_RetCode __pyx_v_ret_code;
-  PyObject *__pyx_r = NULL;
-  __Pyx_RefNannyDeclarations
-  TA_CandleSettingType __pyx_t_1;
-  PyObject *__pyx_t_2 = NULL;
-  __Pyx_RefNannySetupContext("_ta_restore_candle_default_settings", 0);
+      __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(3, 1046, __pyx_L3_error)
 
-  __pyx_t_1 = __Pyx_PyInt_As_TA_CandleSettingType(__pyx_v_settingtype); if (unlikely((__pyx_t_1 == ((TA_CandleSettingType)-1)) && PyErr_Occurred())) __PYX_ERR(0, 131, __pyx_L1_error)
-  __pyx_v_ret_code = TA_RestoreCandleDefaultSettings(__pyx_t_1);
+    }
+    __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_L8_try_end;
+    __pyx_L3_error:;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_RestoreCandleDefaultSettings, __pyx_v_ret_code, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 132, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(((PyTypeObject*)PyExc_Exception))));
+    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(3, 1047, __pyx_L5_except_error)
+      __Pyx_XGOTREF(__pyx_t_5);
+      __Pyx_XGOTREF(__pyx_t_6);
+      __Pyx_XGOTREF(__pyx_t_7);
+
+      __pyx_t_9 = NULL;
+      __Pyx_INCREF(__pyx_builtin_ImportError);
+      __pyx_t_10 = __pyx_builtin_ImportError; 
+      __pyx_t_11 = 1;
+      {
+        PyObject *__pyx_callargs[2] = {__pyx_t_9, __pyx_mstate_global->__pyx_kp_u_numpy__core_umath_failed_to_impo};
+        __pyx_t_8 = __Pyx_PyObject_FastCall(__pyx_t_10, __pyx_callargs+__pyx_t_11, (2-__pyx_t_11) | (__pyx_t_11*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+        __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+        __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+        if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 1048, __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(3, 1048, __pyx_L5_except_error)
+    }
+    goto __pyx_L5_except_error;
+
+    __pyx_L5_except_error:;
+    __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_L8_try_end:;
+  }
 
 
   /* function exit code */
-  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __pyx_r = 0;
   goto __pyx_L0;
   __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_2);
-  __Pyx_AddTraceback("talib._ta_lib._ta_restore_candle_default_settings", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = NULL;
+  __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);
+  __Pyx_XDECREF(__pyx_t_10);
+  __Pyx_AddTraceback("numpy.import_umath", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1;
   __pyx_L0:;
-  __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
 
-static PyArrayObject *__pyx_f_5talib_7_ta_lib_check_array(PyArrayObject *__pyx_v_real) {
-  PyArrayObject *__pyx_r = NULL;
+static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) {
+  int __pyx_r;
   __Pyx_RefNannyDeclarations
-  int __pyx_t_1;
+  PyObject *__pyx_t_1 = NULL;
   PyObject *__pyx_t_2 = NULL;
-  __Pyx_RefNannySetupContext("check_array", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_real);
+  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;
+  PyObject *__pyx_t_9 = NULL;
+  PyObject *__pyx_t_10 = NULL;
+  size_t __pyx_t_11;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("import_ufunc", 0);
 
-  __pyx_t_1 = ((PyArray_TYPE(__pyx_v_real) != NPY_DOUBLE) != 0);
-  if (unlikely(__pyx_t_1)) {
+  {
+    __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:*/ {
 
-    __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple_, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 22, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_2);
-    __Pyx_Raise(__pyx_t_2, 0, 0, 0);
-    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-    __PYX_ERR(2, 22, __pyx_L1_error)
+      __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(3, 1052, __pyx_L3_error)
 
-  }
+    }
+    __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_L8_try_end;
+    __pyx_L3_error:;
 
-  __pyx_t_1 = ((__pyx_v_real->nd != 1) != 0);
-  if (unlikely(__pyx_t_1)) {
+    __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(((PyTypeObject*)PyExc_Exception))));
+    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(3, 1053, __pyx_L5_except_error)
+      __Pyx_XGOTREF(__pyx_t_5);
+      __Pyx_XGOTREF(__pyx_t_6);
+      __Pyx_XGOTREF(__pyx_t_7);
 
-    __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 24, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_2);
-    __Pyx_Raise(__pyx_t_2, 0, 0, 0);
-    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-    __PYX_ERR(2, 24, __pyx_L1_error)
+      __pyx_t_9 = NULL;
+      __Pyx_INCREF(__pyx_builtin_ImportError);
+      __pyx_t_10 = __pyx_builtin_ImportError; 
+      __pyx_t_11 = 1;
+      {
+        PyObject *__pyx_callargs[2] = {__pyx_t_9, __pyx_mstate_global->__pyx_kp_u_numpy__core_umath_failed_to_impo};
+        __pyx_t_8 = __Pyx_PyObject_FastCall(__pyx_t_10, __pyx_callargs+__pyx_t_11, (2-__pyx_t_11) | (__pyx_t_11*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+        __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+        __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+        if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 1054, __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(3, 1054, __pyx_L5_except_error)
+    }
+    goto __pyx_L5_except_error;
 
+    __pyx_L5_except_error:;
+    __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_L8_try_end:;
   }
 
-  __pyx_t_1 = ((!((PyArray_FLAGS(__pyx_v_real) & NPY_C_CONTIGUOUS) != 0)) != 0);
-  if (__pyx_t_1) {
 
-    __pyx_t_2 = ((PyObject *)PyArray_GETCONTIGUOUS(__pyx_v_real)); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 26, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_2);
-    __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_2));
-    __pyx_t_2 = 0;
+  /* 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_XDECREF(__pyx_t_9);
+  __Pyx_XDECREF(__pyx_t_10);
+  __Pyx_AddTraceback("numpy.import_ufunc", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
 
-  }
 
-  __Pyx_XDECREF(((PyObject *)__pyx_r));
-  __Pyx_INCREF(((PyObject *)__pyx_v_real));
-  __pyx_r = __pyx_v_real;
+static CYTHON_INLINE int __pyx_f_5numpy_is_timedelta64_object(PyObject *__pyx_v_obj) {
+  int __pyx_r;
+
+  __pyx_r = PyObject_TypeCheck(__pyx_v_obj, (&PyTimedeltaArrType_Type));
   goto __pyx_L0;
 
 
   /* function exit code */
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_2);
-  __Pyx_AddTraceback("talib._ta_lib.check_array", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = 0;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_real);
-  __Pyx_XGIVEREF((PyObject *)__pyx_r);
-  __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
 
-static npy_intp __pyx_f_5talib_7_ta_lib_check_length2(PyArrayObject *__pyx_v_a1, PyArrayObject *__pyx_v_a2) {
-  npy_intp __pyx_v_length;
-  npy_intp __pyx_r;
-  __Pyx_RefNannyDeclarations
-  int __pyx_t_1;
-  PyObject *__pyx_t_2 = NULL;
-  __Pyx_RefNannySetupContext("check_length2", 0);
+static CYTHON_INLINE int __pyx_f_5numpy_is_datetime64_object(PyObject *__pyx_v_obj) {
+  int __pyx_r;
 
-  __pyx_v_length = (__pyx_v_a1->dimensions[0]);
+  __pyx_r = PyObject_TypeCheck(__pyx_v_obj, (&PyDatetimeArrType_Type));
+  goto __pyx_L0;
 
-  __pyx_t_1 = ((__pyx_v_length != (__pyx_v_a2->dimensions[0])) != 0);
-  if (unlikely(__pyx_t_1)) {
 
-    __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 34, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_2);
-    __Pyx_Raise(__pyx_t_2, 0, 0, 0);
-    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-    __PYX_ERR(2, 34, __pyx_L1_error)
+  /* function exit code */
+  __pyx_L0:;
+  return __pyx_r;
+}
 
-  }
 
-  __pyx_r = __pyx_v_length;
+static CYTHON_INLINE npy_datetime __pyx_f_5numpy_get_datetime64_value(PyObject *__pyx_v_obj) {
+  npy_datetime __pyx_r;
+
+  __pyx_r = ((PyDatetimeScalarObject *)__pyx_v_obj)->obval;
   goto __pyx_L0;
 
 
   /* function exit code */
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_2);
-  __Pyx_AddTraceback("talib._ta_lib.check_length2", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = -1;
   __pyx_L0:;
-  __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
 
-static npy_intp __pyx_f_5talib_7_ta_lib_check_length3(PyArrayObject *__pyx_v_a1, PyArrayObject *__pyx_v_a2, PyArrayObject *__pyx_v_a3) {
-  npy_intp __pyx_v_length;
-  npy_intp __pyx_r;
-  __Pyx_RefNannyDeclarations
-  int __pyx_t_1;
-  PyObject *__pyx_t_2 = NULL;
-  __Pyx_RefNannySetupContext("check_length3", 0);
-
-  __pyx_v_length = (__pyx_v_a1->dimensions[0]);
-
-  __pyx_t_1 = ((__pyx_v_length != (__pyx_v_a2->dimensions[0])) != 0);
-  if (unlikely(__pyx_t_1)) {
+static CYTHON_INLINE npy_timedelta __pyx_f_5numpy_get_timedelta64_value(PyObject *__pyx_v_obj) {
+  npy_timedelta __pyx_r;
 
-    __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 42, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_2);
-    __Pyx_Raise(__pyx_t_2, 0, 0, 0);
-    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-    __PYX_ERR(2, 42, __pyx_L1_error)
+  __pyx_r = ((PyTimedeltaScalarObject *)__pyx_v_obj)->obval;
+  goto __pyx_L0;
 
-  }
 
-  __pyx_t_1 = ((__pyx_v_length != (__pyx_v_a3->dimensions[0])) != 0);
-  if (unlikely(__pyx_t_1)) {
+  /* function exit code */
+  __pyx_L0:;
+  return __pyx_r;
+}
 
-    __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 44, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_2);
-    __Pyx_Raise(__pyx_t_2, 0, 0, 0);
-    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-    __PYX_ERR(2, 44, __pyx_L1_error)
 
-  }
+static CYTHON_INLINE NPY_DATETIMEUNIT __pyx_f_5numpy_get_datetime64_unit(PyObject *__pyx_v_obj) {
+  NPY_DATETIMEUNIT __pyx_r;
 
-  __pyx_r = __pyx_v_length;
+  __pyx_r = ((NPY_DATETIMEUNIT)((PyDatetimeScalarObject *)__pyx_v_obj)->obmeta.base);
   goto __pyx_L0;
 
 
   /* function exit code */
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_2);
-  __Pyx_AddTraceback("talib._ta_lib.check_length3", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = -1;
   __pyx_L0:;
-  __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
 
-static npy_intp __pyx_f_5talib_7_ta_lib_check_length4(PyArrayObject *__pyx_v_a1, PyArrayObject *__pyx_v_a2, PyArrayObject *__pyx_v_a3, PyArrayObject *__pyx_v_a4) {
-  npy_intp __pyx_v_length;
-  npy_intp __pyx_r;
+static PyObject *__pyx_pw_5talib_7_ta_lib_1_ta_check_success(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+static PyObject *__pyx_f_5talib_7_ta_lib__ta_check_success(PyObject *__pyx_v_function_name, TA_RetCode __pyx_v_ret_code, CYTHON_UNUSED int __pyx_skip_dispatch) {
+  PyObject *__pyx_v_description = NULL;
+  PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
-  int __pyx_t_1;
+  PyObject *__pyx_t_1 = NULL;
   PyObject *__pyx_t_2 = NULL;
-  __Pyx_RefNannySetupContext("check_length4", 0);
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7[5];
+  size_t __pyx_t_8;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_ta_check_success", 0);
 
-  __pyx_v_length = (__pyx_v_a1->dimensions[0]);
+  switch (__pyx_v_ret_code) {
+    case 0:
 
-  __pyx_t_1 = ((__pyx_v_length != (__pyx_v_a2->dimensions[0])) != 0);
-  if (unlikely(__pyx_t_1)) {
+    __Pyx_XDECREF(__pyx_r);
+    __Pyx_INCREF(Py_True);
+    __pyx_r = Py_True;
+    goto __pyx_L0;
 
-    __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 52, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_2);
-    __Pyx_Raise(__pyx_t_2, 0, 0, 0);
-    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-    __PYX_ERR(2, 52, __pyx_L1_error)
+    break;
+    case 1:
 
-  }
+    __Pyx_INCREF(__pyx_mstate_global->__pyx_kp_u_Library_Not_Initialized_TA_LIB_N);
+    __pyx_v_description = __pyx_mstate_global->__pyx_kp_u_Library_Not_Initialized_TA_LIB_N;
 
-  __pyx_t_1 = ((__pyx_v_length != (__pyx_v_a3->dimensions[0])) != 0);
-  if (unlikely(__pyx_t_1)) {
+    break;
+    case 2:
 
-    __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 54, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_2);
-    __Pyx_Raise(__pyx_t_2, 0, 0, 0);
-    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-    __PYX_ERR(2, 54, __pyx_L1_error)
+    __Pyx_INCREF(__pyx_mstate_global->__pyx_kp_u_Bad_Parameter_TA_BAD_PARAM);
+    __pyx_v_description = __pyx_mstate_global->__pyx_kp_u_Bad_Parameter_TA_BAD_PARAM;
 
-  }
+    break;
+    case 3:
 
-  __pyx_t_1 = ((__pyx_v_length != (__pyx_v_a4->dimensions[0])) != 0);
-  if (unlikely(__pyx_t_1)) {
+    __Pyx_INCREF(__pyx_mstate_global->__pyx_kp_u_Allocation_Error_TA_ALLOC_ERR);
+    __pyx_v_description = __pyx_mstate_global->__pyx_kp_u_Allocation_Error_TA_ALLOC_ERR;
 
-    __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 56, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_2);
-    __Pyx_Raise(__pyx_t_2, 0, 0, 0);
-    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-    __PYX_ERR(2, 56, __pyx_L1_error)
+    break;
+    case 4:
 
-  }
+    __Pyx_INCREF(__pyx_mstate_global->__pyx_kp_u_Group_Not_Found_TA_GROUP_NOT_FOU);
+    __pyx_v_description = __pyx_mstate_global->__pyx_kp_u_Group_Not_Found_TA_GROUP_NOT_FOU;
 
-  __pyx_r = __pyx_v_length;
-  goto __pyx_L0;
+    break;
+    case 5:
 
+    __Pyx_INCREF(__pyx_mstate_global->__pyx_kp_u_Function_Not_Found_TA_FUNC_NOT_F);
+    __pyx_v_description = __pyx_mstate_global->__pyx_kp_u_Function_Not_Found_TA_FUNC_NOT_F;
 
-  /* function exit code */
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_2);
-  __Pyx_AddTraceback("talib._ta_lib.check_length4", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = -1;
-  __pyx_L0:;
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-
-static npy_int __pyx_f_5talib_7_ta_lib_check_begidx1(npy_intp __pyx_v_length, double *__pyx_v_a1) {
-  double __pyx_v_val;
-  long __pyx_v_i;
-  npy_int __pyx_r;
-  __Pyx_RefNannyDeclarations
-  npy_intp __pyx_t_1;
-  int __pyx_t_2;
-  PyObject *__pyx_t_3 = NULL;
-  __Pyx_RefNannySetupContext("check_begidx1", 0);
-
-  __pyx_t_1 = __pyx_v_length;
-  for (__pyx_v_i = 0; __pyx_v_i < __pyx_t_1; __pyx_v_i++) {
-
-    __pyx_v_val = (__pyx_v_a1[__pyx_v_i]);
-
-    __pyx_t_2 = ((__pyx_v_val != __pyx_v_val) != 0);
-    if (__pyx_t_2) {
-
-      goto __pyx_L3_continue;
-
-    }
-
-    __pyx_r = __pyx_v_i;
-    goto __pyx_L0;
-    __pyx_L3_continue:;
-  }
-  /*else*/ {
-
-    __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 68, __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(2, 68, __pyx_L1_error)
-  }
-
-
-  /* function exit code */
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_3);
-  __Pyx_AddTraceback("talib._ta_lib.check_begidx1", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = -1;
-  __pyx_L0:;
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-
-static npy_int __pyx_f_5talib_7_ta_lib_check_begidx2(npy_intp __pyx_v_length, double *__pyx_v_a1, double *__pyx_v_a2) {
-  double __pyx_v_val;
-  long __pyx_v_i;
-  npy_int __pyx_r;
-  __Pyx_RefNannyDeclarations
-  npy_intp __pyx_t_1;
-  int __pyx_t_2;
-  PyObject *__pyx_t_3 = NULL;
-  __Pyx_RefNannySetupContext("check_begidx2", 0);
-
-  __pyx_t_1 = __pyx_v_length;
-  for (__pyx_v_i = 0; __pyx_v_i < __pyx_t_1; __pyx_v_i++) {
-
-    __pyx_v_val = (__pyx_v_a1[__pyx_v_i]);
+    break;
+    case 6:
 
-    __pyx_t_2 = ((__pyx_v_val != __pyx_v_val) != 0);
-    if (__pyx_t_2) {
+    __Pyx_INCREF(__pyx_mstate_global->__pyx_kp_u_Invalid_Handle_TA_INVALID_HANDLE);
+    __pyx_v_description = __pyx_mstate_global->__pyx_kp_u_Invalid_Handle_TA_INVALID_HANDLE;
 
-      goto __pyx_L3_continue;
+    break;
+    case 7:
 
-    }
+    __Pyx_INCREF(__pyx_mstate_global->__pyx_kp_u_Invalid_Parameter_Holder_TA_INVA);
+    __pyx_v_description = __pyx_mstate_global->__pyx_kp_u_Invalid_Parameter_Holder_TA_INVA;
 
-    __pyx_v_val = (__pyx_v_a2[__pyx_v_i]);
+    break;
+    case 8:
 
-    __pyx_t_2 = ((__pyx_v_val != __pyx_v_val) != 0);
-    if (__pyx_t_2) {
+    __Pyx_INCREF(__pyx_mstate_global->__pyx_kp_u_Invalid_Parameter_Holder_Type_TA);
+    __pyx_v_description = __pyx_mstate_global->__pyx_kp_u_Invalid_Parameter_Holder_Type_TA;
 
-      goto __pyx_L3_continue;
+    break;
+    case 9:
 
-    }
+    __Pyx_INCREF(__pyx_mstate_global->__pyx_kp_u_Invalid_Parameter_Function_TA_IN);
+    __pyx_v_description = __pyx_mstate_global->__pyx_kp_u_Invalid_Parameter_Function_TA_IN;
 
-    __pyx_r = __pyx_v_i;
-    goto __pyx_L0;
-    __pyx_L3_continue:;
-  }
-  /*else*/ {
+    break;
+    case 10:
 
-    __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 82, __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(2, 82, __pyx_L1_error)
-  }
+    __Pyx_INCREF(__pyx_mstate_global->__pyx_kp_u_Input_Not_All_Initialized_TA_INP);
+    __pyx_v_description = __pyx_mstate_global->__pyx_kp_u_Input_Not_All_Initialized_TA_INP;
 
+    break;
+    case 11:
 
-  /* function exit code */
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_3);
-  __Pyx_AddTraceback("talib._ta_lib.check_begidx2", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = -1;
-  __pyx_L0:;
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
+    __Pyx_INCREF(__pyx_mstate_global->__pyx_kp_u_Output_Not_All_Initialized_TA_OU);
+    __pyx_v_description = __pyx_mstate_global->__pyx_kp_u_Output_Not_All_Initialized_TA_OU;
 
+    break;
+    case 12:
 
-static npy_int __pyx_f_5talib_7_ta_lib_check_begidx3(npy_intp __pyx_v_length, double *__pyx_v_a1, double *__pyx_v_a2, double *__pyx_v_a3) {
-  double __pyx_v_val;
-  long __pyx_v_i;
-  npy_int __pyx_r;
-  __Pyx_RefNannyDeclarations
-  npy_intp __pyx_t_1;
-  int __pyx_t_2;
-  PyObject *__pyx_t_3 = NULL;
-  __Pyx_RefNannySetupContext("check_begidx3", 0);
+    __Pyx_INCREF(__pyx_mstate_global->__pyx_kp_u_Out_of_Range_Start_Index_TA_OUT);
+    __pyx_v_description = __pyx_mstate_global->__pyx_kp_u_Out_of_Range_Start_Index_TA_OUT;
 
-  __pyx_t_1 = __pyx_v_length;
-  for (__pyx_v_i = 0; __pyx_v_i < __pyx_t_1; __pyx_v_i++) {
+    break;
+    case 13:
 
-    __pyx_v_val = (__pyx_v_a1[__pyx_v_i]);
+    __Pyx_INCREF(__pyx_mstate_global->__pyx_kp_u_Out_of_Range_End_Index_TA_OUT_OF);
+    __pyx_v_description = __pyx_mstate_global->__pyx_kp_u_Out_of_Range_End_Index_TA_OUT_OF;
 
-    __pyx_t_2 = ((__pyx_v_val != __pyx_v_val) != 0);
-    if (__pyx_t_2) {
+    break;
+    case 14:
 
-      goto __pyx_L3_continue;
+    __Pyx_INCREF(__pyx_mstate_global->__pyx_kp_u_Invalid_List_Type_TA_INVALID_LIS);
+    __pyx_v_description = __pyx_mstate_global->__pyx_kp_u_Invalid_List_Type_TA_INVALID_LIS;
 
-    }
+    break;
+    case 15:
 
-    __pyx_v_val = (__pyx_v_a2[__pyx_v_i]);
+    __Pyx_INCREF(__pyx_mstate_global->__pyx_kp_u_Bad_Object_TA_BAD_OBJECT);
+    __pyx_v_description = __pyx_mstate_global->__pyx_kp_u_Bad_Object_TA_BAD_OBJECT;
 
-    __pyx_t_2 = ((__pyx_v_val != __pyx_v_val) != 0);
-    if (__pyx_t_2) {
+    break;
+    case 16:
 
-      goto __pyx_L3_continue;
+    __Pyx_INCREF(__pyx_mstate_global->__pyx_kp_u_Not_Supported_TA_NOT_SUPPORTED);
+    __pyx_v_description = __pyx_mstate_global->__pyx_kp_u_Not_Supported_TA_NOT_SUPPORTED;
 
-    }
+    break;
+    case 0x1388:
 
-    __pyx_v_val = (__pyx_v_a3[__pyx_v_i]);
+    __Pyx_INCREF(__pyx_mstate_global->__pyx_kp_u_Internal_Error_TA_INTERNAL_ERROR);
+    __pyx_v_description = __pyx_mstate_global->__pyx_kp_u_Internal_Error_TA_INTERNAL_ERROR;
 
-    __pyx_t_2 = ((__pyx_v_val != __pyx_v_val) != 0);
-    if (__pyx_t_2) {
+    break;
+    case 0xFFFF:
 
-      goto __pyx_L3_continue;
+    __Pyx_INCREF(__pyx_mstate_global->__pyx_kp_u_Unknown_Error_TA_UNKNOWN_ERR);
+    __pyx_v_description = __pyx_mstate_global->__pyx_kp_u_Unknown_Error_TA_UNKNOWN_ERR;
 
-    }
+    break;
+    default:
 
-    __pyx_r = __pyx_v_i;
-    goto __pyx_L0;
-    __pyx_L3_continue:;
+    __Pyx_INCREF(__pyx_mstate_global->__pyx_kp_u_Unknown_Error);
+    __pyx_v_description = __pyx_mstate_global->__pyx_kp_u_Unknown_Error;
+    break;
   }
-  /*else*/ {
 
-    __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 99, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_3);
-    __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+  __pyx_t_2 = NULL;
+  __Pyx_INCREF((PyObject *)(((PyTypeObject*)PyExc_Exception)));
+  __pyx_t_3 = ((PyObject *)(((PyTypeObject*)PyExc_Exception))); 
+
+  __pyx_t_4 = __Pyx_PyUnicode_Unicode(__pyx_v_function_name); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 48, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = __Pyx_PyLong_From_TA_RetCode(__pyx_v_ret_code); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 48, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_6 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Str(__pyx_t_5), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 48, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_7[0] = __pyx_t_4;
+  __pyx_t_7[1] = __pyx_mstate_global->__pyx_kp_u_function_failed_with_error_code;
+  __pyx_t_7[2] = __pyx_t_6;
+  __pyx_t_7[3] = __pyx_mstate_global->__pyx_kp_u_;
+  __pyx_t_7[4] = __pyx_v_description;
+
+  __pyx_t_5 = __Pyx_PyUnicode_Join(__pyx_t_7, 5, __Pyx_PyUnicode_GET_LENGTH(__pyx_t_4) + 33 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6) + 2 + __Pyx_PyUnicode_GET_LENGTH(__pyx_v_description), 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_4) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_v_description));
+  if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 47, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  __pyx_t_8 = 1;
+  {
+    PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_t_5};
+    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
     __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-    __PYX_ERR(2, 99, __pyx_L1_error)
+    if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 47, __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(1, 47, __pyx_L1_error)
 
 
   /* function exit code */
   __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
   __Pyx_XDECREF(__pyx_t_3);
-  __Pyx_AddTraceback("talib._ta_lib.check_begidx3", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = -1;
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_AddTraceback("talib._ta_lib._ta_check_success", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
   __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_description);
+  __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-
-static npy_int __pyx_f_5talib_7_ta_lib_check_begidx4(npy_intp __pyx_v_length, double *__pyx_v_a1, double *__pyx_v_a2, double *__pyx_v_a3, double *__pyx_v_a4) {
-  double __pyx_v_val;
-  long __pyx_v_i;
-  npy_int __pyx_r;
+/* Python wrapper */
+static PyObject *__pyx_pw_5talib_7_ta_lib_1_ta_check_success(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib__ta_check_success, "_ta_check_success(str function_name, TA_RetCode ret_code)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_1_ta_check_success = {"_ta_check_success", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_1_ta_check_success, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib__ta_check_success};
+static PyObject *__pyx_pw_5talib_7_ta_lib_1_ta_check_success(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyObject *__pyx_v_function_name = 0;
+  TA_RetCode __pyx_v_ret_code;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  npy_intp __pyx_t_1;
-  int __pyx_t_2;
-  PyObject *__pyx_t_3 = NULL;
-  __Pyx_RefNannySetupContext("check_begidx4", 0);
-
-  __pyx_t_1 = __pyx_v_length;
-  for (__pyx_v_i = 0; __pyx_v_i < __pyx_t_1; __pyx_v_i++) {
-
-    __pyx_v_val = (__pyx_v_a1[__pyx_v_i]);
-
-    __pyx_t_2 = ((__pyx_v_val != __pyx_v_val) != 0);
-    if (__pyx_t_2) {
-
-      goto __pyx_L3_continue;
-
-    }
-
-    __pyx_v_val = (__pyx_v_a2[__pyx_v_i]);
-
-    __pyx_t_2 = ((__pyx_v_val != __pyx_v_val) != 0);
-    if (__pyx_t_2) {
-
-      goto __pyx_L3_continue;
-
-    }
-
-    __pyx_v_val = (__pyx_v_a3[__pyx_v_i]);
-
-    __pyx_t_2 = ((__pyx_v_val != __pyx_v_val) != 0);
-    if (__pyx_t_2) {
-
-      goto __pyx_L3_continue;
-
-    }
-
-    __pyx_v_val = (__pyx_v_a4[__pyx_v_i]);
-
-    __pyx_t_2 = ((__pyx_v_val != __pyx_v_val) != 0);
-    if (__pyx_t_2) {
-
-      goto __pyx_L3_continue;
-
+  __Pyx_RefNannySetupContext("_ta_check_success (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_function_name,&__pyx_mstate_global->__pyx_n_u_ret_code,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(1, 6, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(1, 6, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 6, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "_ta_check_success", 0) < (0)) __PYX_ERR(1, 6, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("_ta_check_success", 1, 2, 2, i); __PYX_ERR(1, 6, __pyx_L3_error) }
+      }
+    } else if (unlikely(__pyx_nargs != 2)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 6, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(1, 6, __pyx_L3_error)
     }
-
-    __pyx_r = __pyx_v_i;
-    goto __pyx_L0;
-    __pyx_L3_continue:;
+    __pyx_v_function_name = ((PyObject*)values[0]);
+    __pyx_v_ret_code = __Pyx_PyLong_As_TA_RetCode(values[1]); if (unlikely((__pyx_v_ret_code == ((TA_RetCode)-1)) && PyErr_Occurred())) __PYX_ERR(1, 6, __pyx_L3_error)
   }
-  /*else*/ {
-
-    __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 119, __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(2, 119, __pyx_L1_error)
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("_ta_check_success", 1, 2, 2, __pyx_nargs); __PYX_ERR(1, 6, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
   }
-
+  __Pyx_AddTraceback("talib._ta_lib._ta_check_success", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_function_name), (&PyUnicode_Type), 1, "function_name", 1))) __PYX_ERR(1, 6, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib__ta_check_success(__pyx_self, __pyx_v_function_name, __pyx_v_ret_code);
 
   /* function exit code */
+  goto __pyx_L0;
   __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_3);
-  __Pyx_AddTraceback("talib._ta_lib.check_begidx4", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = -1;
+  __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-
-static PyArrayObject *__pyx_f_5talib_7_ta_lib_make_double_array(npy_intp __pyx_v_length, int __pyx_v_lookback) {
-  PyArrayObject *__pyx_v_outreal = 0;
-  double *__pyx_v_outreal_data;
-  long __pyx_v_i;
-  PyArrayObject *__pyx_r = NULL;
+static PyObject *__pyx_pf_5talib_7_ta_lib__ta_check_success(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_function_name, TA_RetCode __pyx_v_ret_code) {
+  PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  npy_intp __pyx_t_2;
-  int __pyx_t_3;
-  npy_intp __pyx_t_4;
-  __Pyx_RefNannySetupContext("make_double_array", 0);
-
-  __pyx_t_1 = ((PyObject *)PyArray_EMPTY(1, (&__pyx_v_length), NPY_DOUBLE, NPY_DEFAULT)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 125, __pyx_L1_error)
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_ta_check_success", 0);
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_v_function_name, __pyx_v_ret_code, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 6, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
+  __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
-
-  __pyx_v_outreal_data = ((double *)__pyx_v_outreal->data);
-
-  __pyx_t_2 = __pyx_v_length;
-  __pyx_t_3 = __pyx_v_lookback;
-  if (((__pyx_t_2 < __pyx_t_3) != 0)) {
-    __pyx_t_4 = __pyx_t_2;
-  } else {
-    __pyx_t_4 = __pyx_t_3;
-  }
-  __pyx_t_2 = __pyx_t_4;
-  for (__pyx_v_i = 0; __pyx_v_i < __pyx_t_2; __pyx_v_i++) {
-
-    (__pyx_v_outreal_data[__pyx_v_i]) = __pyx_v_5talib_7_ta_lib_NaN;
-  }
-
-  __Pyx_XDECREF(((PyObject *)__pyx_r));
-  __Pyx_INCREF(((PyObject *)__pyx_v_outreal));
-  __pyx_r = __pyx_v_outreal;
   goto __pyx_L0;
 
-
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.make_double_array", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = 0;
+  __Pyx_AddTraceback("talib._ta_lib._ta_check_success", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
-  __Pyx_XGIVEREF((PyObject *)__pyx_r);
+  __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
 
-static PyArrayObject *__pyx_f_5talib_7_ta_lib_make_int_array(npy_intp __pyx_v_length, int __pyx_v_lookback) {
-  PyArrayObject *__pyx_v_outinteger = 0;
-  int *__pyx_v_outinteger_data;
-  long __pyx_v_i;
-  PyArrayObject *__pyx_r = NULL;
+/* Python wrapper */
+static PyObject *__pyx_pw_5talib_7_ta_lib_3_ta_initialize(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_2_ta_initialize, "_ta_initialize()");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_3_ta_initialize = {"_ta_initialize", (PyCFunction)__pyx_pw_5talib_7_ta_lib_3_ta_initialize, METH_NOARGS, __pyx_doc_5talib_7_ta_lib_2_ta_initialize};
+static PyObject *__pyx_pw_5talib_7_ta_lib_3_ta_initialize(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused) {
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
-  npy_intp __pyx_t_2;
-  int __pyx_t_3;
-  npy_intp __pyx_t_4;
-  __Pyx_RefNannySetupContext("make_int_array", 0);
-
-  __pyx_t_1 = ((PyObject *)PyArray_EMPTY(1, (&__pyx_v_length), NPY_INT32, NPY_DEFAULT)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 135, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1);
-  __pyx_t_1 = 0;
+  __Pyx_RefNannySetupContext("_ta_initialize (wrapper)", 0);
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_2_ta_initialize(__pyx_self);
 
-  __pyx_v_outinteger_data = ((int *)__pyx_v_outinteger->data);
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
 
-  __pyx_t_2 = __pyx_v_length;
-  __pyx_t_3 = __pyx_v_lookback;
-  if (((__pyx_t_2 < __pyx_t_3) != 0)) {
-    __pyx_t_4 = __pyx_t_2;
-  } else {
-    __pyx_t_4 = __pyx_t_3;
-  }
-  __pyx_t_2 = __pyx_t_4;
-  for (__pyx_v_i = 0; __pyx_v_i < __pyx_t_2; __pyx_v_i++) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_2_ta_initialize(CYTHON_UNUSED PyObject *__pyx_self) {
+  TA_RetCode __pyx_v_ret_code;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_ta_initialize", 0);
 
-    (__pyx_v_outinteger_data[__pyx_v_i]) = 0;
-  }
+  __pyx_v_ret_code = TA_Initialize();
 
-  __Pyx_XDECREF(((PyObject *)__pyx_r));
-  __Pyx_INCREF(((PyObject *)__pyx_v_outinteger));
-  __pyx_r = __pyx_v_outinteger;
-  goto __pyx_L0;
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_Initialize, __pyx_v_ret_code, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 53, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
 
   /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.make_int_array", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = 0;
+  __Pyx_AddTraceback("talib._ta_lib._ta_initialize", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_outinteger);
-  __Pyx_XGIVEREF((PyObject *)__pyx_r);
+  __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_19ACOS(PyObject *__pyx_self, PyObject *__pyx_v_real); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_18ACOS[] = " ACOS(real)\n\n    Vector Trigonometric ACos (Math Transform)\n\n    Inputs:\n        real: (any ndarray)\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_19ACOS = {"ACOS", (PyCFunction)__pyx_pw_5talib_7_ta_lib_19ACOS, METH_O, __pyx_doc_5talib_7_ta_lib_18ACOS};
-static PyObject *__pyx_pw_5talib_7_ta_lib_19ACOS(PyObject *__pyx_self, PyObject *__pyx_v_real) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_5_ta_shutdown(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_4_ta_shutdown, "_ta_shutdown()");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_5_ta_shutdown = {"_ta_shutdown", (PyCFunction)__pyx_pw_5talib_7_ta_lib_5_ta_shutdown, METH_NOARGS, __pyx_doc_5talib_7_ta_lib_4_ta_shutdown};
+static PyObject *__pyx_pw_5talib_7_ta_lib_5_ta_shutdown(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused) {
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("ACOS (wrapper)", 0);
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(2, 144, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_18ACOS(__pyx_self, ((PyArrayObject *)__pyx_v_real));
+  __Pyx_RefNannySetupContext("_ta_shutdown (wrapper)", 0);
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_4_ta_shutdown(__pyx_self);
 
   /* function exit code */
-  goto __pyx_L0;
-  __pyx_L1_error:;
-  __pyx_r = NULL;
-  __pyx_L0:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_18ACOS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) {
-  npy_intp __pyx_v_length;
-  int __pyx_v_begidx;
-  int __pyx_v_endidx;
-  int __pyx_v_lookback;
-  TA_RetCode __pyx_v_retCode;
-  int __pyx_v_outbegidx;
-  int __pyx_v_outnbelement;
-  PyArrayObject *__pyx_v_outreal = 0;
+static PyObject *__pyx_pf_5talib_7_ta_lib_4_ta_shutdown(CYTHON_UNUSED PyObject *__pyx_self) {
+  TA_RetCode __pyx_v_ret_code;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  npy_int __pyx_t_2;
-  __Pyx_RefNannySetupContext("ACOS", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_real);
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 161, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
-
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_v_real->data)); if (unlikely(__pyx_t_2 == ((npy_int)-1))) __PYX_ERR(2, 163, __pyx_L1_error)
-  __pyx_v_begidx = __pyx_t_2;
-
-  __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
-
-  __pyx_v_lookback = (__pyx_v_begidx + TA_ACOS_Lookback());
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 166, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
-  __pyx_t_1 = 0;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_ta_shutdown", 0);
 
-  __pyx_v_retCode = TA_ACOS(0, __pyx_v_endidx, (((double *)__pyx_v_real->data) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_v_outreal->data) + __pyx_v_lookback));
+  __pyx_v_ret_code = TA_Shutdown();
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_ACOS, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 168, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_Shutdown, __pyx_v_ret_code, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 58, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
-  __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outreal));
-  __pyx_r = ((PyObject *)__pyx_v_outreal);
-  goto __pyx_L0;
-
 
   /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.ACOS", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib._ta_shutdown", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
-  __Pyx_XDECREF((PyObject *)__pyx_v_real);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -6333,176 +6853,190 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_18ACOS(CYTHON_UNUSED PyObject *__pyx_s
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_21AD(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_20AD[] = " AD(high, low, close, volume)\n\n    Chaikin A/D Line (Volume Indicators)\n\n    Inputs:\n        prices: ['high', 'low', 'close', 'volume']\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_21AD = {"AD", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_21AD, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_20AD};
-static PyObject *__pyx_pw_5talib_7_ta_lib_21AD(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_high = 0;
-  PyArrayObject *__pyx_v_low = 0;
-  PyArrayObject *__pyx_v_close = 0;
-  PyArrayObject *__pyx_v_volume = 0;
+static PyObject *__pyx_pw_5talib_7_ta_lib_7MA_Type_1__init__(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_7MA_Type___init__, "MA_Type.__init__(self)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_7MA_Type_1__init__ = {"__init__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_7MA_Type_1__init__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_7MA_Type___init__};
+static PyObject *__pyx_pw_5talib_7_ta_lib_7MA_Type_1__init__(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyObject *__pyx_v_self = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("AD (wrapper)", 0);
+  __Pyx_RefNannySetupContext("__init__ (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,&__pyx_n_s_volume,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(1, 63, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 63, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("AD", 1, 4, 4, 1); __PYX_ERR(2, 173, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("AD", 1, 4, 4, 2); __PYX_ERR(2, 173, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_volume)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("AD", 1, 4, 4, 3); __PYX_ERR(2, 173, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "AD") < 0)) __PYX_ERR(2, 173, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__init__", 0) < (0)) __PYX_ERR(1, 63, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__init__", 1, 1, 1, i); __PYX_ERR(1, 63, __pyx_L3_error) }
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
+    } else if (unlikely(__pyx_nargs != 1)) {
       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[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 63, __pyx_L3_error)
     }
-    __pyx_v_high = ((PyArrayObject *)values[0]);
-    __pyx_v_low = ((PyArrayObject *)values[1]);
-    __pyx_v_close = ((PyArrayObject *)values[2]);
-    __pyx_v_volume = ((PyArrayObject *)values[3]);
+    __pyx_v_self = values[0];
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("AD", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 173, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("__init__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 63, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.AD", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.MA_Type.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(2, 173, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(2, 173, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(2, 173, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_volume), __pyx_ptype_5numpy_ndarray, 0, "volume", 0))) __PYX_ERR(2, 173, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_20AD(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_volume);
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_7MA_Type___init__(__pyx_self, __pyx_v_self);
 
   /* function exit code */
-  goto __pyx_L0;
-  __pyx_L1_error:;
-  __pyx_r = NULL;
-  __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_20AD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, PyArrayObject *__pyx_v_volume) {
-  npy_intp __pyx_v_length;
-  int __pyx_v_begidx;
-  int __pyx_v_endidx;
-  int __pyx_v_lookback;
-  TA_RetCode __pyx_v_retCode;
-  int __pyx_v_outbegidx;
-  int __pyx_v_outnbelement;
-  PyArrayObject *__pyx_v_outreal = 0;
+static PyObject *__pyx_pf_5talib_7_ta_lib_7MA_Type___init__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  npy_intp __pyx_t_2;
-  npy_int __pyx_t_3;
-  __Pyx_RefNannySetupContext("AD", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_high);
-  __Pyx_INCREF((PyObject *)__pyx_v_low);
-  __Pyx_INCREF((PyObject *)__pyx_v_close);
-  __Pyx_INCREF((PyObject *)__pyx_v_volume);
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__init__", 0);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 190, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyDict_NewPresized(9); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 65, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
+  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_MA_Type); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 65, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_SMA); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 65, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  if (PyDict_SetItem(__pyx_t_1, __pyx_t_3, __pyx_mstate_global->__pyx_kp_u_Simple_Moving_Average) < (0)) __PYX_ERR(1, 65, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 191, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_MA_Type); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 66, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_EMA); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 66, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (PyDict_SetItem(__pyx_t_1, __pyx_t_2, __pyx_mstate_global->__pyx_kp_u_Exponential_Moving_Average) < (0)) __PYX_ERR(1, 65, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 192, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
+  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_MA_Type); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 67, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_WMA); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 67, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  if (PyDict_SetItem(__pyx_t_1, __pyx_t_3, __pyx_mstate_global->__pyx_kp_u_Weighted_Moving_Average) < (0)) __PYX_ERR(1, 65, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_volume)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 193, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_volume, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_MA_Type); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 68, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_DEMA); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 68, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (PyDict_SetItem(__pyx_t_1, __pyx_t_2, __pyx_mstate_global->__pyx_kp_u_Double_Exponential_Moving_Averag) < (0)) __PYX_ERR(1, 65, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_volume); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(2, 194, __pyx_L1_error)
-  __pyx_v_length = __pyx_t_2;
+  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_MA_Type); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 69, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_TEMA); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 69, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  if (PyDict_SetItem(__pyx_t_1, __pyx_t_3, __pyx_mstate_global->__pyx_kp_u_Triple_Exponential_Moving_Averag) < (0)) __PYX_ERR(1, 65, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
-  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_v_high->data), ((double *)__pyx_v_low->data), ((double *)__pyx_v_close->data), ((double *)__pyx_v_volume->data)); if (unlikely(__pyx_t_3 == ((npy_int)-1))) __PYX_ERR(2, 195, __pyx_L1_error)
-  __pyx_v_begidx = __pyx_t_3;
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_MA_Type); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 70, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_TRIMA); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 70, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (PyDict_SetItem(__pyx_t_1, __pyx_t_2, __pyx_mstate_global->__pyx_kp_u_Triangular_Moving_Average) < (0)) __PYX_ERR(1, 65, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
+  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_MA_Type); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 71, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_KAMA); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 71, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  if (PyDict_SetItem(__pyx_t_1, __pyx_t_3, __pyx_mstate_global->__pyx_kp_u_Kaufman_Adaptive_Moving_Average) < (0)) __PYX_ERR(1, 65, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_AD_Lookback());
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_MA_Type); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 72, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_MAMA); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 72, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (PyDict_SetItem(__pyx_t_1, __pyx_t_2, __pyx_mstate_global->__pyx_kp_u_MESA_Adaptive_Moving_Average) < (0)) __PYX_ERR(1, 65, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 198, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
-  __pyx_t_1 = 0;
-
-  __pyx_v_retCode = TA_AD(0, __pyx_v_endidx, (((double *)__pyx_v_high->data) + __pyx_v_begidx), (((double *)__pyx_v_low->data) + __pyx_v_begidx), (((double *)__pyx_v_close->data) + __pyx_v_begidx), (((double *)__pyx_v_volume->data) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_v_outreal->data) + __pyx_v_lookback));
+  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_MA_Type); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 73, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_T3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 73, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  if (PyDict_SetItem(__pyx_t_1, __pyx_t_3, __pyx_mstate_global->__pyx_kp_u_Triple_Generalized_Double_Expone) < (0)) __PYX_ERR(1, 65, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_AD, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 200, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
+  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_lookup, __pyx_t_1) < (0)) __PYX_ERR(1, 64, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
-  __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outreal));
-  __pyx_r = ((PyObject *)__pyx_v_outreal);
-  goto __pyx_L0;
-
 
   /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.AD", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("talib._ta_lib.MA_Type.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
-  __Pyx_XDECREF((PyObject *)__pyx_v_high);
-  __Pyx_XDECREF((PyObject *)__pyx_v_low);
-  __Pyx_XDECREF((PyObject *)__pyx_v_close);
-  __Pyx_XDECREF((PyObject *)__pyx_v_volume);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -6510,138 +7044,127 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_20AD(CYTHON_UNUSED PyObject *__pyx_sel
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_23ADD(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_22ADD[] = " ADD(real0, real1)\n\n    Vector Arithmetic Add (Math Operators)\n\n    Inputs:\n        real0: (any ndarray)\n        real1: (any ndarray)\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_23ADD = {"ADD", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_23ADD, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_22ADD};
-static PyObject *__pyx_pw_5talib_7_ta_lib_23ADD(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_real0 = 0;
-  PyArrayObject *__pyx_v_real1 = 0;
+static PyObject *__pyx_pw_5talib_7_ta_lib_7MA_Type_3__getitem__(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_7MA_Type_2__getitem__, "MA_Type.__getitem__(self, type_)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_7MA_Type_3__getitem__ = {"__getitem__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_7MA_Type_3__getitem__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_7MA_Type_2__getitem__};
+static PyObject *__pyx_pw_5talib_7_ta_lib_7MA_Type_3__getitem__(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyObject *__pyx_v_self = 0;
+  PyObject *__pyx_v_type_ = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("ADD (wrapper)", 0);
+  __Pyx_RefNannySetupContext("__getitem__ (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real0,&__pyx_n_s_real1,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);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,&__pyx_mstate_global->__pyx_n_u_type,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(1, 76, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(1, 76, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 76, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real0)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real1)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("ADD", 1, 2, 2, 1); __PYX_ERR(2, 205, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "ADD") < 0)) __PYX_ERR(2, 205, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__getitem__", 0) < (0)) __PYX_ERR(1, 76, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__getitem__", 1, 2, 2, i); __PYX_ERR(1, 76, __pyx_L3_error) }
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
+    } else if (unlikely(__pyx_nargs != 2)) {
       goto __pyx_L5_argtuple_error;
     } else {
-      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 76, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(1, 76, __pyx_L3_error)
     }
-    __pyx_v_real0 = ((PyArrayObject *)values[0]);
-    __pyx_v_real1 = ((PyArrayObject *)values[1]);
+    __pyx_v_self = values[0];
+    __pyx_v_type_ = values[1];
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("ADD", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 205, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("__getitem__", 1, 2, 2, __pyx_nargs); __PYX_ERR(1, 76, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.ADD", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.MA_Type.__getitem__", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real0), __pyx_ptype_5numpy_ndarray, 0, "real0", 0))) __PYX_ERR(2, 205, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real1), __pyx_ptype_5numpy_ndarray, 0, "real1", 0))) __PYX_ERR(2, 205, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_22ADD(__pyx_self, __pyx_v_real0, __pyx_v_real1);
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_7MA_Type_2__getitem__(__pyx_self, __pyx_v_self, __pyx_v_type_);
 
   /* function exit code */
-  goto __pyx_L0;
-  __pyx_L1_error:;
-  __pyx_r = NULL;
-  __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_22ADD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real0, PyArrayObject *__pyx_v_real1) {
-  npy_intp __pyx_v_length;
-  int __pyx_v_begidx;
-  int __pyx_v_endidx;
-  int __pyx_v_lookback;
-  TA_RetCode __pyx_v_retCode;
-  int __pyx_v_outbegidx;
-  int __pyx_v_outnbelement;
-  PyArrayObject *__pyx_v_outreal = 0;
+static PyObject *__pyx_pf_5talib_7_ta_lib_7MA_Type_2__getitem__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_type_) {
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  npy_intp __pyx_t_2;
-  npy_int __pyx_t_3;
-  __Pyx_RefNannySetupContext("ADD", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_real0);
-  __Pyx_INCREF((PyObject *)__pyx_v_real1);
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 223, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_real0, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 224, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_real1, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_real0, __pyx_v_real1); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(2, 225, __pyx_L1_error)
-  __pyx_v_length = __pyx_t_2;
-
-  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx2(__pyx_v_length, ((double *)__pyx_v_real0->data), ((double *)__pyx_v_real1->data)); if (unlikely(__pyx_t_3 == ((npy_int)-1))) __PYX_ERR(2, 226, __pyx_L1_error)
-  __pyx_v_begidx = __pyx_t_3;
-
-  __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
-
-  __pyx_v_lookback = (__pyx_v_begidx + TA_ADD_Lookback());
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 229, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
-  __pyx_t_1 = 0;
-
-  __pyx_v_retCode = TA_ADD(0, __pyx_v_endidx, (((double *)__pyx_v_real0->data) + __pyx_v_begidx), (((double *)__pyx_v_real1->data) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_v_outreal->data) + __pyx_v_lookback));
+  PyObject *__pyx_t_2 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__getitem__", 0);
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_ADD, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 231, __pyx_L1_error)
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_lookup); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 77, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyObject_GetItem(__pyx_t_1, __pyx_v_type_); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 77, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-
-  __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outreal));
-  __pyx_r = ((PyObject *)__pyx_v_outreal);
+  __pyx_r = __pyx_t_2;
+  __pyx_t_2 = 0;
   goto __pyx_L0;
 
 
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.ADD", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("talib._ta_lib.MA_Type.__getitem__", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
-  __Pyx_XDECREF((PyObject *)__pyx_v_real0);
-  __Pyx_XDECREF((PyObject *)__pyx_v_real1);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -6649,210 +7172,139 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_22ADD(CYTHON_UNUSED PyObject *__pyx_se
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_25ADOSC(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_24ADOSC[] = " ADOSC(high, low, close, volume[, fastperiod=?, slowperiod=?])\n\n    Chaikin A/D Oscillator (Volume Indicators)\n\n    Inputs:\n        prices: ['high', 'low', 'close', 'volume']\n    Parameters:\n        fastperiod: 3\n        slowperiod: 10\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_25ADOSC = {"ADOSC", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_25ADOSC, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_24ADOSC};
-static PyObject *__pyx_pw_5talib_7_ta_lib_25ADOSC(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_high = 0;
-  PyArrayObject *__pyx_v_low = 0;
-  PyArrayObject *__pyx_v_close = 0;
-  PyArrayObject *__pyx_v_volume = 0;
-  int __pyx_v_fastperiod;
-  int __pyx_v_slowperiod;
+static PyObject *__pyx_pw_5talib_7_ta_lib_7_ta_set_unstable_period(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_6_ta_set_unstable_period, "_ta_set_unstable_period(name, period)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_7_ta_set_unstable_period = {"_ta_set_unstable_period", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_7_ta_set_unstable_period, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_6_ta_set_unstable_period};
+static PyObject *__pyx_pw_5talib_7_ta_lib_7_ta_set_unstable_period(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyObject *__pyx_v_name = 0;
+  PyObject *__pyx_v_period = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("ADOSC (wrapper)", 0);
+  __Pyx_RefNannySetupContext("_ta_set_unstable_period (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,&__pyx_n_s_volume,&__pyx_n_s_fastperiod,&__pyx_n_s_slowperiod,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);
-        CYTHON_FALLTHROUGH;
-        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
-        CYTHON_FALLTHROUGH;
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_name,&__pyx_mstate_global->__pyx_n_u_period,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(1, 90, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(1, 90, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 90, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("ADOSC", 0, 4, 6, 1); __PYX_ERR(2, 236, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("ADOSC", 0, 4, 6, 2); __PYX_ERR(2, 236, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_volume)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("ADOSC", 0, 4, 6, 3); __PYX_ERR(2, 236, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  4:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_fastperiod);
-          if (value) { values[4] = value; kw_args--; }
-        }
-        CYTHON_FALLTHROUGH;
-        case  5:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_slowperiod);
-          if (value) { values[5] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "ADOSC") < 0)) __PYX_ERR(2, 236, __pyx_L3_error)
-      }
-    } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
-        CYTHON_FALLTHROUGH;
-        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
-        CYTHON_FALLTHROUGH;
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-        break;
-        default: goto __pyx_L5_argtuple_error;
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "_ta_set_unstable_period", 0) < (0)) __PYX_ERR(1, 90, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("_ta_set_unstable_period", 1, 2, 2, i); __PYX_ERR(1, 90, __pyx_L3_error) }
       }
-    }
-    __pyx_v_high = ((PyArrayObject *)values[0]);
-    __pyx_v_low = ((PyArrayObject *)values[1]);
-    __pyx_v_close = ((PyArrayObject *)values[2]);
-    __pyx_v_volume = ((PyArrayObject *)values[3]);
-    if (values[4]) {
-      __pyx_v_fastperiod = __Pyx_PyInt_As_int(values[4]); if (unlikely((__pyx_v_fastperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 236, __pyx_L3_error)
-    } else {
-      __pyx_v_fastperiod = ((int)-2147483648);
-    }
-    if (values[5]) {
-      __pyx_v_slowperiod = __Pyx_PyInt_As_int(values[5]); if (unlikely((__pyx_v_slowperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 236, __pyx_L3_error)
+    } else if (unlikely(__pyx_nargs != 2)) {
+      goto __pyx_L5_argtuple_error;
     } else {
-      __pyx_v_slowperiod = ((int)-2147483648);
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 90, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(1, 90, __pyx_L3_error)
     }
+    __pyx_v_name = values[0];
+    __pyx_v_period = values[1];
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("ADOSC", 0, 4, 6, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 236, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("_ta_set_unstable_period", 1, 2, 2, __pyx_nargs); __PYX_ERR(1, 90, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.ADOSC", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib._ta_set_unstable_period", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(2, 236, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(2, 236, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(2, 236, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_volume), __pyx_ptype_5numpy_ndarray, 0, "volume", 0))) __PYX_ERR(2, 236, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_24ADOSC(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_volume, __pyx_v_fastperiod, __pyx_v_slowperiod);
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_6_ta_set_unstable_period(__pyx_self, __pyx_v_name, __pyx_v_period);
 
   /* function exit code */
-  goto __pyx_L0;
-  __pyx_L1_error:;
-  __pyx_r = NULL;
-  __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_24ADOSC(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, PyArrayObject *__pyx_v_volume, int __pyx_v_fastperiod, int __pyx_v_slowperiod) {
-  npy_intp __pyx_v_length;
-  int __pyx_v_begidx;
-  int __pyx_v_endidx;
-  int __pyx_v_lookback;
-  TA_RetCode __pyx_v_retCode;
-  int __pyx_v_outbegidx;
-  int __pyx_v_outnbelement;
-  PyArrayObject *__pyx_v_outreal = 0;
+static PyObject *__pyx_pf_5talib_7_ta_lib_6_ta_set_unstable_period(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_name, PyObject *__pyx_v_period) {
+  TA_RetCode __pyx_v_ret_code;
+  TA_FuncUnstId __pyx_v_id;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  npy_intp __pyx_t_2;
-  npy_int __pyx_t_3;
-  __Pyx_RefNannySetupContext("ADOSC", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_high);
-  __Pyx_INCREF((PyObject *)__pyx_v_low);
-  __Pyx_INCREF((PyObject *)__pyx_v_close);
-  __Pyx_INCREF((PyObject *)__pyx_v_volume);
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 256, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 257, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 258, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_volume)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 259, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_volume, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_volume); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(2, 260, __pyx_L1_error)
-  __pyx_v_length = __pyx_t_2;
-
-  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_v_high->data), ((double *)__pyx_v_low->data), ((double *)__pyx_v_close->data), ((double *)__pyx_v_volume->data)); if (unlikely(__pyx_t_3 == ((npy_int)-1))) __PYX_ERR(2, 261, __pyx_L1_error)
-  __pyx_v_begidx = __pyx_t_3;
-
-  __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
-
-  __pyx_v_lookback = (__pyx_v_begidx + TA_ADOSC_Lookback(__pyx_v_fastperiod, __pyx_v_slowperiod));
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 264, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
-  __pyx_t_1 = 0;
-
-  __pyx_v_retCode = TA_ADOSC(0, __pyx_v_endidx, (((double *)__pyx_v_high->data) + __pyx_v_begidx), (((double *)__pyx_v_low->data) + __pyx_v_begidx), (((double *)__pyx_v_close->data) + __pyx_v_begidx), (((double *)__pyx_v_volume->data) + __pyx_v_begidx), __pyx_v_fastperiod, __pyx_v_slowperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_v_outreal->data) + __pyx_v_lookback));
+  PyObject *__pyx_t_2 = NULL;
+  TA_FuncUnstId __pyx_t_3;
+  unsigned int __pyx_t_4;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_ta_set_unstable_period", 0);
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_ADOSC, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 266, __pyx_L1_error)
+  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_ta_func_unst_ids); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 92, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyObject_GetItem(__pyx_t_1, __pyx_v_name); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 92, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_3 = __Pyx_PyLong_As_TA_FuncUnstId(__pyx_t_2); if (unlikely((__pyx_t_3 == ((TA_FuncUnstId)-1)) && PyErr_Occurred())) __PYX_ERR(1, 92, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_v_id = __pyx_t_3;
 
-  __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outreal));
-  __pyx_r = ((PyObject *)__pyx_v_outreal);
-  goto __pyx_L0;
+  __pyx_t_4 = __Pyx_PyLong_As_unsigned_int(__pyx_v_period); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(1, 93, __pyx_L1_error)
+  __pyx_v_ret_code = TA_SetUnstablePeriod(__pyx_v_id, __pyx_t_4);
+
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_SetUnstablePeriod, __pyx_v_ret_code, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 94, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
 
   /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.ADOSC", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("talib._ta_lib._ta_set_unstable_period", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
-  __Pyx_XDECREF((PyObject *)__pyx_v_high);
-  __Pyx_XDECREF((PyObject *)__pyx_v_low);
-  __Pyx_XDECREF((PyObject *)__pyx_v_close);
-  __Pyx_XDECREF((PyObject *)__pyx_v_volume);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -6860,175 +7312,130 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_24ADOSC(CYTHON_UNUSED PyObject *__pyx_
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_27ADX(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_26ADX[] = " ADX(high, low, close[, timeperiod=?])\n\n    Average Directional Movement Index (Momentum Indicators)\n\n    Inputs:\n        prices: ['high', 'low', 'close']\n    Parameters:\n        timeperiod: 14\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_27ADX = {"ADX", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_27ADX, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_26ADX};
-static PyObject *__pyx_pw_5talib_7_ta_lib_27ADX(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_high = 0;
-  PyArrayObject *__pyx_v_low = 0;
-  PyArrayObject *__pyx_v_close = 0;
-  int __pyx_v_timeperiod;
+static PyObject *__pyx_pw_5talib_7_ta_lib_9_ta_get_unstable_period(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_8_ta_get_unstable_period, "_ta_get_unstable_period(name)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_9_ta_get_unstable_period = {"_ta_get_unstable_period", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_9_ta_get_unstable_period, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_8_ta_get_unstable_period};
+static PyObject *__pyx_pw_5talib_7_ta_lib_9_ta_get_unstable_period(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyObject *__pyx_v_name = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("ADX (wrapper)", 0);
+  __Pyx_RefNannySetupContext("_ta_get_unstable_period (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,&__pyx_n_s_timeperiod,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_name,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(1, 96, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 96, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("ADX", 0, 3, 4, 1); __PYX_ERR(2, 271, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("ADX", 0, 3, 4, 2); __PYX_ERR(2, 271, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod);
-          if (value) { values[3] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "ADX") < 0)) __PYX_ERR(2, 271, __pyx_L3_error)
-      }
-    } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-        break;
-        default: goto __pyx_L5_argtuple_error;
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "_ta_get_unstable_period", 0) < (0)) __PYX_ERR(1, 96, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("_ta_get_unstable_period", 1, 1, 1, i); __PYX_ERR(1, 96, __pyx_L3_error) }
       }
-    }
-    __pyx_v_high = ((PyArrayObject *)values[0]);
-    __pyx_v_low = ((PyArrayObject *)values[1]);
-    __pyx_v_close = ((PyArrayObject *)values[2]);
-    if (values[3]) {
-      __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[3]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 271, __pyx_L3_error)
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
     } else {
-      __pyx_v_timeperiod = ((int)-2147483648);
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 96, __pyx_L3_error)
     }
+    __pyx_v_name = values[0];
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("ADX", 0, 3, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 271, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("_ta_get_unstable_period", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 96, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.ADX", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib._ta_get_unstable_period", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(2, 271, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(2, 271, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(2, 271, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_26ADX(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_timeperiod);
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_8_ta_get_unstable_period(__pyx_self, __pyx_v_name);
 
   /* function exit code */
-  goto __pyx_L0;
-  __pyx_L1_error:;
-  __pyx_r = NULL;
-  __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_26ADX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod) {
-  npy_intp __pyx_v_length;
-  int __pyx_v_begidx;
-  int __pyx_v_endidx;
-  int __pyx_v_lookback;
-  TA_RetCode __pyx_v_retCode;
-  int __pyx_v_outbegidx;
-  int __pyx_v_outnbelement;
-  PyArrayObject *__pyx_v_outreal = 0;
+static PyObject *__pyx_pf_5talib_7_ta_lib_8_ta_get_unstable_period(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_name) {
+  unsigned int __pyx_v_period;
+  TA_FuncUnstId __pyx_v_id;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  npy_intp __pyx_t_2;
-  npy_int __pyx_t_3;
-  __Pyx_RefNannySetupContext("ADX", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_high);
-  __Pyx_INCREF((PyObject *)__pyx_v_low);
-  __Pyx_INCREF((PyObject *)__pyx_v_close);
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 290, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 291, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 292, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(2, 293, __pyx_L1_error)
-  __pyx_v_length = __pyx_t_2;
-
-  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx3(__pyx_v_length, ((double *)__pyx_v_high->data), ((double *)__pyx_v_low->data), ((double *)__pyx_v_close->data)); if (unlikely(__pyx_t_3 == ((npy_int)-1))) __PYX_ERR(2, 294, __pyx_L1_error)
-  __pyx_v_begidx = __pyx_t_3;
-
-  __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
-
-  __pyx_v_lookback = (__pyx_v_begidx + TA_ADX_Lookback(__pyx_v_timeperiod));
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 297, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
-  __pyx_t_1 = 0;
-
-  __pyx_v_retCode = TA_ADX(0, __pyx_v_endidx, (((double *)__pyx_v_high->data) + __pyx_v_begidx), (((double *)__pyx_v_low->data) + __pyx_v_begidx), (((double *)__pyx_v_close->data) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_v_outreal->data) + __pyx_v_lookback));
+  PyObject *__pyx_t_2 = NULL;
+  TA_FuncUnstId __pyx_t_3;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_ta_get_unstable_period", 0);
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_ADX, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 299, __pyx_L1_error)
+  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_ta_func_unst_ids); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 98, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyObject_GetItem(__pyx_t_1, __pyx_v_name); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 98, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_3 = __Pyx_PyLong_As_TA_FuncUnstId(__pyx_t_2); if (unlikely((__pyx_t_3 == ((TA_FuncUnstId)-1)) && PyErr_Occurred())) __PYX_ERR(1, 98, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_v_id = __pyx_t_3;
+
+  __pyx_v_period = TA_GetUnstablePeriod(__pyx_v_id);
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outreal));
-  __pyx_r = ((PyObject *)__pyx_v_outreal);
+  __pyx_t_2 = __Pyx_PyLong_From_unsigned_int(__pyx_v_period); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 100, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_r = __pyx_t_2;
+  __pyx_t_2 = 0;
   goto __pyx_L0;
 
 
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.ADX", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("talib._ta_lib._ta_get_unstable_period", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
-  __Pyx_XDECREF((PyObject *)__pyx_v_high);
-  __Pyx_XDECREF((PyObject *)__pyx_v_low);
-  __Pyx_XDECREF((PyObject *)__pyx_v_close);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -7036,175 +7443,167 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_26ADX(CYTHON_UNUSED PyObject *__pyx_se
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_29ADXR(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_28ADXR[] = " ADXR(high, low, close[, timeperiod=?])\n\n    Average Directional Movement Index Rating (Momentum Indicators)\n\n    Inputs:\n        prices: ['high', 'low', 'close']\n    Parameters:\n        timeperiod: 14\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_29ADXR = {"ADXR", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_29ADXR, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_28ADXR};
-static PyObject *__pyx_pw_5talib_7_ta_lib_29ADXR(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_high = 0;
-  PyArrayObject *__pyx_v_low = 0;
-  PyArrayObject *__pyx_v_close = 0;
-  int __pyx_v_timeperiod;
+static PyObject *__pyx_pw_5talib_7_ta_lib_11_ta_set_compatibility(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_10_ta_set_compatibility, "_ta_set_compatibility(value)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_11_ta_set_compatibility = {"_ta_set_compatibility", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_11_ta_set_compatibility, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_10_ta_set_compatibility};
+static PyObject *__pyx_pw_5talib_7_ta_lib_11_ta_set_compatibility(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyObject *__pyx_v_value = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("ADXR (wrapper)", 0);
+  __Pyx_RefNannySetupContext("_ta_set_compatibility (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,&__pyx_n_s_timeperiod,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_value,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(1, 102, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 102, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("ADXR", 0, 3, 4, 1); __PYX_ERR(2, 304, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("ADXR", 0, 3, 4, 2); __PYX_ERR(2, 304, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod);
-          if (value) { values[3] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "ADXR") < 0)) __PYX_ERR(2, 304, __pyx_L3_error)
-      }
-    } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-        break;
-        default: goto __pyx_L5_argtuple_error;
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "_ta_set_compatibility", 0) < (0)) __PYX_ERR(1, 102, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("_ta_set_compatibility", 1, 1, 1, i); __PYX_ERR(1, 102, __pyx_L3_error) }
       }
-    }
-    __pyx_v_high = ((PyArrayObject *)values[0]);
-    __pyx_v_low = ((PyArrayObject *)values[1]);
-    __pyx_v_close = ((PyArrayObject *)values[2]);
-    if (values[3]) {
-      __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[3]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 304, __pyx_L3_error)
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
     } else {
-      __pyx_v_timeperiod = ((int)-2147483648);
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 102, __pyx_L3_error)
     }
+    __pyx_v_value = values[0];
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("ADXR", 0, 3, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 304, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("_ta_set_compatibility", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 102, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.ADXR", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib._ta_set_compatibility", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(2, 304, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(2, 304, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(2, 304, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_28ADXR(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_timeperiod);
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_10_ta_set_compatibility(__pyx_self, __pyx_v_value);
 
   /* function exit code */
-  goto __pyx_L0;
-  __pyx_L1_error:;
-  __pyx_r = NULL;
-  __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_28ADXR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod) {
-  npy_intp __pyx_v_length;
-  int __pyx_v_begidx;
-  int __pyx_v_endidx;
-  int __pyx_v_lookback;
-  TA_RetCode __pyx_v_retCode;
-  int __pyx_v_outbegidx;
-  int __pyx_v_outnbelement;
-  PyArrayObject *__pyx_v_outreal = 0;
+static PyObject *__pyx_pf_5talib_7_ta_lib_10_ta_set_compatibility(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_value) {
+  TA_RetCode __pyx_v_ret_code;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
-  npy_intp __pyx_t_2;
-  npy_int __pyx_t_3;
-  __Pyx_RefNannySetupContext("ADXR", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_high);
-  __Pyx_INCREF((PyObject *)__pyx_v_low);
-  __Pyx_INCREF((PyObject *)__pyx_v_close);
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 323, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
+  TA_Compatibility __pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_ta_set_compatibility", 0);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 324, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_PyLong_As_TA_Compatibility(__pyx_v_value); if (unlikely((__pyx_t_1 == ((TA_Compatibility)-1)) && PyErr_Occurred())) __PYX_ERR(1, 104, __pyx_L1_error)
+  __pyx_v_ret_code = TA_SetCompatibility(__pyx_t_1);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 325, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_SetCompatibility, __pyx_v_ret_code, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 105, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(2, 326, __pyx_L1_error)
-  __pyx_v_length = __pyx_t_2;
 
-  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx3(__pyx_v_length, ((double *)__pyx_v_high->data), ((double *)__pyx_v_low->data), ((double *)__pyx_v_close->data)); if (unlikely(__pyx_t_3 == ((npy_int)-1))) __PYX_ERR(2, 327, __pyx_L1_error)
-  __pyx_v_begidx = __pyx_t_3;
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("talib._ta_lib._ta_set_compatibility", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
 
-  __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_ADXR_Lookback(__pyx_v_timeperiod));
+/* Python wrapper */
+static PyObject *__pyx_pw_5talib_7_ta_lib_13_ta_get_compatibility(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_12_ta_get_compatibility, "_ta_get_compatibility()");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_13_ta_get_compatibility = {"_ta_get_compatibility", (PyCFunction)__pyx_pw_5talib_7_ta_lib_13_ta_get_compatibility, METH_NOARGS, __pyx_doc_5talib_7_ta_lib_12_ta_get_compatibility};
+static PyObject *__pyx_pw_5talib_7_ta_lib_13_ta_get_compatibility(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused) {
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("_ta_get_compatibility (wrapper)", 0);
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_12_ta_get_compatibility(__pyx_self);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 330, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
-  __pyx_t_1 = 0;
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
 
-  __pyx_v_retCode = TA_ADXR(0, __pyx_v_endidx, (((double *)__pyx_v_high->data) + __pyx_v_begidx), (((double *)__pyx_v_low->data) + __pyx_v_begidx), (((double *)__pyx_v_close->data) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_v_outreal->data) + __pyx_v_lookback));
+static PyObject *__pyx_pf_5talib_7_ta_lib_12_ta_get_compatibility(CYTHON_UNUSED PyObject *__pyx_self) {
+  int __pyx_v_value;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_ta_get_compatibility", 0);
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_ADXR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 332, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v_value = TA_GetCompatibility();
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outreal));
-  __pyx_r = ((PyObject *)__pyx_v_outreal);
+  __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_value); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 110, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
   goto __pyx_L0;
 
 
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.ADXR", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib._ta_get_compatibility", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
-  __Pyx_XDECREF((PyObject *)__pyx_v_high);
-  __Pyx_XDECREF((PyObject *)__pyx_v_low);
-  __Pyx_XDECREF((PyObject *)__pyx_v_close);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -7212,167 +7611,148 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_28ADXR(CYTHON_UNUSED PyObject *__pyx_s
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_31APO(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_30APO[] = " APO(real[, fastperiod=?, slowperiod=?, matype=?])\n\n    Absolute Price Oscillator (Momentum Indicators)\n\n    Inputs:\n        real: (any ndarray)\n    Parameters:\n        fastperiod: 12\n        slowperiod: 26\n        matype: 0 (Simple Moving Average)\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_31APO = {"APO", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_31APO, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_30APO};
-static PyObject *__pyx_pw_5talib_7_ta_lib_31APO(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_real = 0;
-  int __pyx_v_fastperiod;
-  int __pyx_v_slowperiod;
-  int __pyx_v_matype;
+static PyObject *__pyx_pw_5talib_7_ta_lib_15_ta_set_candle_settings(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_14_ta_set_candle_settings, "_ta_set_candle_settings(settingtype, rangetype, avgperiod, factor)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_15_ta_set_candle_settings = {"_ta_set_candle_settings", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_15_ta_set_candle_settings, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_14_ta_set_candle_settings};
+static PyObject *__pyx_pw_5talib_7_ta_lib_15_ta_set_candle_settings(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyObject *__pyx_v_settingtype = 0;
+  PyObject *__pyx_v_rangetype = 0;
+  PyObject *__pyx_v_avgperiod = 0;
+  PyObject *__pyx_v_factor = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("APO (wrapper)", 0);
+  __Pyx_RefNannySetupContext("_ta_set_candle_settings (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_fastperiod,&__pyx_n_s_slowperiod,&__pyx_n_s_matype,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_settingtype,&__pyx_mstate_global->__pyx_n_u_rangetype,&__pyx_mstate_global->__pyx_n_u_avgperiod,&__pyx_mstate_global->__pyx_n_u_factor,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(1, 124, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(1, 124, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(1, 124, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(1, 124, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 124, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_fastperiod);
-          if (value) { values[1] = value; kw_args--; }
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_slowperiod);
-          if (value) { values[2] = value; kw_args--; }
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_matype);
-          if (value) { values[3] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "APO") < 0)) __PYX_ERR(2, 337, __pyx_L3_error)
-      }
-    } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-        break;
-        default: goto __pyx_L5_argtuple_error;
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "_ta_set_candle_settings", 0) < (0)) __PYX_ERR(1, 124, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("_ta_set_candle_settings", 1, 4, 4, i); __PYX_ERR(1, 124, __pyx_L3_error) }
       }
-    }
-    __pyx_v_real = ((PyArrayObject *)values[0]);
-    if (values[1]) {
-      __pyx_v_fastperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_fastperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 337, __pyx_L3_error)
-    } else {
-      __pyx_v_fastperiod = ((int)-2147483648);
-    }
-    if (values[2]) {
-      __pyx_v_slowperiod = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_slowperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 337, __pyx_L3_error)
-    } else {
-      __pyx_v_slowperiod = ((int)-2147483648);
-    }
-    if (values[3]) {
-      __pyx_v_matype = __Pyx_PyInt_As_int(values[3]); if (unlikely((__pyx_v_matype == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 337, __pyx_L3_error)
+    } else if (unlikely(__pyx_nargs != 4)) {
+      goto __pyx_L5_argtuple_error;
     } else {
-      __pyx_v_matype = ((int)0);
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 124, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(1, 124, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(1, 124, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(1, 124, __pyx_L3_error)
     }
+    __pyx_v_settingtype = values[0];
+    __pyx_v_rangetype = values[1];
+    __pyx_v_avgperiod = values[2];
+    __pyx_v_factor = values[3];
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("APO", 0, 1, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 337, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("_ta_set_candle_settings", 1, 4, 4, __pyx_nargs); __PYX_ERR(1, 124, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.APO", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib._ta_set_candle_settings", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(2, 337, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_30APO(__pyx_self, __pyx_v_real, __pyx_v_fastperiod, __pyx_v_slowperiod, __pyx_v_matype);
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_14_ta_set_candle_settings(__pyx_self, __pyx_v_settingtype, __pyx_v_rangetype, __pyx_v_avgperiod, __pyx_v_factor);
 
   /* function exit code */
-  goto __pyx_L0;
-  __pyx_L1_error:;
-  __pyx_r = NULL;
-  __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_30APO(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_fastperiod, int __pyx_v_slowperiod, int __pyx_v_matype) {
-  npy_intp __pyx_v_length;
-  int __pyx_v_begidx;
-  int __pyx_v_endidx;
-  int __pyx_v_lookback;
-  TA_RetCode __pyx_v_retCode;
-  int __pyx_v_outbegidx;
-  int __pyx_v_outnbelement;
-  PyArrayObject *__pyx_v_outreal = 0;
+static PyObject *__pyx_pf_5talib_7_ta_lib_14_ta_set_candle_settings(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_settingtype, PyObject *__pyx_v_rangetype, PyObject *__pyx_v_avgperiod, PyObject *__pyx_v_factor) {
+  TA_RetCode __pyx_v_ret_code;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
-  npy_int __pyx_t_2;
-  __Pyx_RefNannySetupContext("APO", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_real);
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 358, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
-
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_v_real->data)); if (unlikely(__pyx_t_2 == ((npy_int)-1))) __PYX_ERR(2, 360, __pyx_L1_error)
-  __pyx_v_begidx = __pyx_t_2;
-
-  __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
-
-  __pyx_v_lookback = (__pyx_v_begidx + TA_APO_Lookback(__pyx_v_fastperiod, __pyx_v_slowperiod, __pyx_v_matype));
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 363, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
-  __pyx_t_1 = 0;
-
-  __pyx_v_retCode = TA_APO(0, __pyx_v_endidx, (((double *)__pyx_v_real->data) + __pyx_v_begidx), __pyx_v_fastperiod, __pyx_v_slowperiod, __pyx_v_matype, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_v_outreal->data) + __pyx_v_lookback));
+  TA_CandleSettingType __pyx_t_1;
+  TA_RangeType __pyx_t_2;
+  int __pyx_t_3;
+  double __pyx_t_4;
+  PyObject *__pyx_t_5 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_ta_set_candle_settings", 0);
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_APO, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 365, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_PyLong_As_TA_CandleSettingType(__pyx_v_settingtype); if (unlikely((__pyx_t_1 == ((TA_CandleSettingType)-1)) && PyErr_Occurred())) __PYX_ERR(1, 126, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyLong_As_TA_RangeType(__pyx_v_rangetype); if (unlikely((__pyx_t_2 == ((TA_RangeType)-1)) && PyErr_Occurred())) __PYX_ERR(1, 126, __pyx_L1_error)
+  __pyx_t_3 = __Pyx_PyLong_As_int(__pyx_v_avgperiod); if (unlikely((__pyx_t_3 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 126, __pyx_L1_error)
+  __pyx_t_4 = __Pyx_PyFloat_AsDouble(__pyx_v_factor); if (unlikely((__pyx_t_4 == (double)-1) && PyErr_Occurred())) __PYX_ERR(1, 126, __pyx_L1_error)
+  __pyx_v_ret_code = TA_SetCandleSettings(__pyx_t_1, __pyx_t_2, __pyx_t_3, __pyx_t_4);
 
-  __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outreal));
-  __pyx_r = ((PyObject *)__pyx_v_outreal);
-  goto __pyx_L0;
+  __pyx_t_5 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_SetCandleSettings, __pyx_v_ret_code, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 127, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
 
 
   /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
   __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.APO", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_AddTraceback("talib._ta_lib._ta_set_candle_settings", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
-  __Pyx_XDECREF((PyObject *)__pyx_v_real);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -7380,560 +7760,829 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_30APO(CYTHON_UNUSED PyObject *__pyx_se
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_33AROON(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_32AROON[] = " AROON(high, low[, timeperiod=?])\n\n    Aroon (Momentum Indicators)\n\n    Inputs:\n        prices: ['high', 'low']\n    Parameters:\n        timeperiod: 14\n    Outputs:\n        aroondown\n        aroonup\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_33AROON = {"AROON", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_33AROON, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_32AROON};
-static PyObject *__pyx_pw_5talib_7_ta_lib_33AROON(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_high = 0;
-  PyArrayObject *__pyx_v_low = 0;
-  int __pyx_v_timeperiod;
+static PyObject *__pyx_pw_5talib_7_ta_lib_17_ta_restore_candle_default_settings(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_16_ta_restore_candle_default_settings, "_ta_restore_candle_default_settings(settingtype)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_17_ta_restore_candle_default_settings = {"_ta_restore_candle_default_settings", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_17_ta_restore_candle_default_settings, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_16_ta_restore_candle_default_settings};
+static PyObject *__pyx_pw_5talib_7_ta_lib_17_ta_restore_candle_default_settings(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyObject *__pyx_v_settingtype = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("AROON (wrapper)", 0);
+  __Pyx_RefNannySetupContext("_ta_restore_candle_default_settings (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_timeperiod,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);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_settingtype,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(1, 129, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 129, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("AROON", 0, 2, 3, 1); __PYX_ERR(2, 370, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod);
-          if (value) { values[2] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "AROON") < 0)) __PYX_ERR(2, 370, __pyx_L3_error)
-      }
-    } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-        break;
-        default: goto __pyx_L5_argtuple_error;
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "_ta_restore_candle_default_settings", 0) < (0)) __PYX_ERR(1, 129, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("_ta_restore_candle_default_settings", 1, 1, 1, i); __PYX_ERR(1, 129, __pyx_L3_error) }
       }
-    }
-    __pyx_v_high = ((PyArrayObject *)values[0]);
-    __pyx_v_low = ((PyArrayObject *)values[1]);
-    if (values[2]) {
-      __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 370, __pyx_L3_error)
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
     } else {
-      __pyx_v_timeperiod = ((int)-2147483648);
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 129, __pyx_L3_error)
     }
+    __pyx_v_settingtype = values[0];
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("AROON", 0, 2, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 370, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("_ta_restore_candle_default_settings", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 129, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.AROON", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib._ta_restore_candle_default_settings", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(2, 370, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(2, 370, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_32AROON(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_timeperiod);
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_16_ta_restore_candle_default_settings(__pyx_self, __pyx_v_settingtype);
+
+  /* function exit code */
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_5talib_7_ta_lib_16_ta_restore_candle_default_settings(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_settingtype) {
+  TA_RetCode __pyx_v_ret_code;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  TA_CandleSettingType __pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_ta_restore_candle_default_settings", 0);
+
+  __pyx_t_1 = __Pyx_PyLong_As_TA_CandleSettingType(__pyx_v_settingtype); if (unlikely((__pyx_t_1 == ((TA_CandleSettingType)-1)) && PyErr_Occurred())) __PYX_ERR(1, 131, __pyx_L1_error)
+  __pyx_v_ret_code = TA_RestoreCandleDefaultSettings(__pyx_t_1);
+
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_RestoreCandleDefaultSettings, __pyx_v_ret_code, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 132, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
 
   /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
   goto __pyx_L0;
   __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("talib._ta_lib._ta_restore_candle_default_settings", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_32AROON(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, int __pyx_v_timeperiod) {
-  npy_intp __pyx_v_length;
-  int __pyx_v_begidx;
-  int __pyx_v_endidx;
-  int __pyx_v_lookback;
-  TA_RetCode __pyx_v_retCode;
-  int __pyx_v_outbegidx;
-  int __pyx_v_outnbelement;
-  PyArrayObject *__pyx_v_outaroondown = 0;
-  PyArrayObject *__pyx_v_outaroonup = 0;
-  PyObject *__pyx_r = NULL;
-  __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
-  npy_intp __pyx_t_2;
-  npy_int __pyx_t_3;
-  __Pyx_RefNannySetupContext("AROON", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_high);
-  __Pyx_INCREF((PyObject *)__pyx_v_low);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 391, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
+static PyArrayObject *__pyx_f_5talib_7_ta_lib_check_array(PyArrayObject *__pyx_v_real) {
+  PyArrayObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  size_t __pyx_t_5;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("check_array", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 392, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
+  __pyx_t_1 = (PyArray_TYPE(__pyx_v_real) != NPY_DOUBLE);
+  if (unlikely(__pyx_t_1)) {
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_high, __pyx_v_low); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(2, 393, __pyx_L1_error)
-  __pyx_v_length = __pyx_t_2;
+    __pyx_t_3 = NULL;
+    __Pyx_INCREF((PyObject *)(((PyTypeObject*)PyExc_Exception)));
+    __pyx_t_4 = ((PyObject *)(((PyTypeObject*)PyExc_Exception))); 
+    __pyx_t_5 = 1;
+    {
+      PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_mstate_global->__pyx_kp_u_input_array_type_is_not_double};
+      __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 22, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+    }
+    __Pyx_Raise(__pyx_t_2, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __PYX_ERR(4, 22, __pyx_L1_error)
 
-  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx2(__pyx_v_length, ((double *)__pyx_v_high->data), ((double *)__pyx_v_low->data)); if (unlikely(__pyx_t_3 == ((npy_int)-1))) __PYX_ERR(2, 394, __pyx_L1_error)
-  __pyx_v_begidx = __pyx_t_3;
+  }
 
-  __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
+  __pyx_t_1 = (__pyx_f_5numpy_7ndarray_4ndim_ndim(__pyx_v_real) != 1);
+  if (unlikely(__pyx_t_1)) {
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_AROON_Lookback(__pyx_v_timeperiod));
+    __pyx_t_4 = NULL;
+    __Pyx_INCREF((PyObject *)(((PyTypeObject*)PyExc_Exception)));
+    __pyx_t_3 = ((PyObject *)(((PyTypeObject*)PyExc_Exception))); 
+    __pyx_t_5 = 1;
+    {
+      PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_input_array_has_wrong_dimensions};
+      __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 24, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+    }
+    __Pyx_Raise(__pyx_t_2, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __PYX_ERR(4, 24, __pyx_L1_error)
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 397, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_v_outaroondown = ((PyArrayObject *)__pyx_t_1);
-  __pyx_t_1 = 0;
+  }
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 398, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_v_outaroonup = ((PyArrayObject *)__pyx_t_1);
-  __pyx_t_1 = 0;
+  __pyx_t_1 = (!((PyArray_FLAGS(__pyx_v_real) & NPY_ARRAY_C_CONTIGUOUS) != 0));
+  if (__pyx_t_1) {
 
-  __pyx_v_retCode = TA_AROON(0, __pyx_v_endidx, (((double *)__pyx_v_high->data) + __pyx_v_begidx), (((double *)__pyx_v_low->data) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_v_outaroondown->data) + __pyx_v_lookback), (((double *)__pyx_v_outaroonup->data) + __pyx_v_lookback));
+    __pyx_t_2 = ((PyObject *)PyArray_GETCONTIGUOUS(__pyx_v_real)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 26, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_2));
+    __pyx_t_2 = 0;
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_AROON, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 400, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  }
 
-  __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 401, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outaroondown));
-  __Pyx_GIVEREF(((PyObject *)__pyx_v_outaroondown));
-  PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_outaroondown));
-  __Pyx_INCREF(((PyObject *)__pyx_v_outaroonup));
-  __Pyx_GIVEREF(((PyObject *)__pyx_v_outaroonup));
-  PyTuple_SET_ITEM(__pyx_t_1, 1, ((PyObject *)__pyx_v_outaroonup));
-  __pyx_r = __pyx_t_1;
-  __pyx_t_1 = 0;
+  __Pyx_XDECREF((PyObject *)__pyx_r);
+  __Pyx_INCREF((PyObject *)__pyx_v_real);
+  __pyx_r = __pyx_v_real;
   goto __pyx_L0;
 
 
   /* function exit code */
   __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.AROON", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = NULL;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_AddTraceback("talib._ta_lib.check_array", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_outaroondown);
-  __Pyx_XDECREF((PyObject *)__pyx_v_outaroonup);
-  __Pyx_XDECREF((PyObject *)__pyx_v_high);
-  __Pyx_XDECREF((PyObject *)__pyx_v_low);
-  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_XDECREF((PyObject *)__pyx_v_real);
+  __Pyx_XGIVEREF((PyObject *)__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
 
-/* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_35AROONOSC(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_34AROONOSC[] = " AROONOSC(high, low[, timeperiod=?])\n\n    Aroon Oscillator (Momentum Indicators)\n\n    Inputs:\n        prices: ['high', 'low']\n    Parameters:\n        timeperiod: 14\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_35AROONOSC = {"AROONOSC", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_35AROONOSC, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_34AROONOSC};
-static PyObject *__pyx_pw_5talib_7_ta_lib_35AROONOSC(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_high = 0;
-  PyArrayObject *__pyx_v_low = 0;
-  int __pyx_v_timeperiod;
-  PyObject *__pyx_r = 0;
+static npy_intp __pyx_f_5talib_7_ta_lib_check_length2(PyArrayObject *__pyx_v_a1, PyArrayObject *__pyx_v_a2) {
+  npy_intp __pyx_v_length;
+  npy_intp __pyx_r;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("AROONOSC (wrapper)", 0);
-  {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_timeperiod,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);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-        CYTHON_FALLTHROUGH;
-        case  0: break;
-        default: goto __pyx_L5_argtuple_error;
-      }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("AROONOSC", 0, 2, 3, 1); __PYX_ERR(2, 405, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod);
-          if (value) { values[2] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "AROONOSC") < 0)) __PYX_ERR(2, 405, __pyx_L3_error)
-      }
-    } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-        break;
-        default: goto __pyx_L5_argtuple_error;
-      }
-    }
-    __pyx_v_high = ((PyArrayObject *)values[0]);
-    __pyx_v_low = ((PyArrayObject *)values[1]);
-    if (values[2]) {
-      __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 405, __pyx_L3_error)
-    } else {
-      __pyx_v_timeperiod = ((int)-2147483648);
+  int __pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  size_t __pyx_t_5;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("check_length2", 0);
+
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_a1)[0]);
+
+  __pyx_t_1 = (__pyx_v_length != (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_a2)[0]));
+  if (unlikely(__pyx_t_1)) {
+
+    __pyx_t_3 = NULL;
+    __Pyx_INCREF((PyObject *)(((PyTypeObject*)PyExc_Exception)));
+    __pyx_t_4 = ((PyObject *)(((PyTypeObject*)PyExc_Exception))); 
+    __pyx_t_5 = 1;
+    {
+      PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_mstate_global->__pyx_kp_u_input_array_lengths_are_differen};
+      __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 34, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
     }
+    __Pyx_Raise(__pyx_t_2, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __PYX_ERR(4, 34, __pyx_L1_error)
+
   }
-  goto __pyx_L4_argument_unpacking_done;
-  __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("AROONOSC", 0, 2, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 405, __pyx_L3_error)
-  __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.AROONOSC", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __Pyx_RefNannyFinishContext();
-  return NULL;
-  __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(2, 405, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(2, 405, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_34AROONOSC(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_timeperiod);
 
-  /* function exit code */
+  __pyx_r = __pyx_v_length;
   goto __pyx_L0;
+
+
+  /* function exit code */
   __pyx_L1_error:;
-  __pyx_r = NULL;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_AddTraceback("talib._ta_lib.check_length2", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1;
   __pyx_L0:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_34AROONOSC(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, int __pyx_v_timeperiod) {
+
+static npy_intp __pyx_f_5talib_7_ta_lib_check_length3(PyArrayObject *__pyx_v_a1, PyArrayObject *__pyx_v_a2, PyArrayObject *__pyx_v_a3) {
   npy_intp __pyx_v_length;
-  int __pyx_v_begidx;
-  int __pyx_v_endidx;
-  int __pyx_v_lookback;
-  TA_RetCode __pyx_v_retCode;
-  int __pyx_v_outbegidx;
-  int __pyx_v_outnbelement;
-  PyArrayObject *__pyx_v_outreal = 0;
-  PyObject *__pyx_r = NULL;
+  npy_intp __pyx_r;
   __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
-  npy_intp __pyx_t_2;
-  npy_int __pyx_t_3;
-  __Pyx_RefNannySetupContext("AROONOSC", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_high);
-  __Pyx_INCREF((PyObject *)__pyx_v_low);
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 424, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 425, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
+  int __pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  size_t __pyx_t_5;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("check_length3", 0);
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_high, __pyx_v_low); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(2, 426, __pyx_L1_error)
-  __pyx_v_length = __pyx_t_2;
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_a1)[0]);
 
-  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx2(__pyx_v_length, ((double *)__pyx_v_high->data), ((double *)__pyx_v_low->data)); if (unlikely(__pyx_t_3 == ((npy_int)-1))) __PYX_ERR(2, 427, __pyx_L1_error)
-  __pyx_v_begidx = __pyx_t_3;
+  __pyx_t_1 = (__pyx_v_length != (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_a2)[0]));
+  if (unlikely(__pyx_t_1)) {
 
-  __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
+    __pyx_t_3 = NULL;
+    __Pyx_INCREF((PyObject *)(((PyTypeObject*)PyExc_Exception)));
+    __pyx_t_4 = ((PyObject *)(((PyTypeObject*)PyExc_Exception))); 
+    __pyx_t_5 = 1;
+    {
+      PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_mstate_global->__pyx_kp_u_input_array_lengths_are_differen};
+      __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 42, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+    }
+    __Pyx_Raise(__pyx_t_2, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __PYX_ERR(4, 42, __pyx_L1_error)
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_AROONOSC_Lookback(__pyx_v_timeperiod));
+  }
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 430, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
-  __pyx_t_1 = 0;
+  __pyx_t_1 = (__pyx_v_length != (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_a3)[0]));
+  if (unlikely(__pyx_t_1)) {
 
-  __pyx_v_retCode = TA_AROONOSC(0, __pyx_v_endidx, (((double *)__pyx_v_high->data) + __pyx_v_begidx), (((double *)__pyx_v_low->data) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_v_outreal->data) + __pyx_v_lookback));
+    __pyx_t_4 = NULL;
+    __Pyx_INCREF((PyObject *)(((PyTypeObject*)PyExc_Exception)));
+    __pyx_t_3 = ((PyObject *)(((PyTypeObject*)PyExc_Exception))); 
+    __pyx_t_5 = 1;
+    {
+      PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_input_array_lengths_are_differen};
+      __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 44, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+    }
+    __Pyx_Raise(__pyx_t_2, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __PYX_ERR(4, 44, __pyx_L1_error)
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_AROONOSC, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 432, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  }
 
-  __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outreal));
-  __pyx_r = ((PyObject *)__pyx_v_outreal);
+  __pyx_r = __pyx_v_length;
   goto __pyx_L0;
 
 
   /* function exit code */
   __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.AROONOSC", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = NULL;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_AddTraceback("talib._ta_lib.check_length3", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
-  __Pyx_XDECREF((PyObject *)__pyx_v_high);
-  __Pyx_XDECREF((PyObject *)__pyx_v_low);
-  __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
 
-/* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_37ASIN(PyObject *__pyx_self, PyObject *__pyx_v_real); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_36ASIN[] = " ASIN(real)\n\n    Vector Trigonometric ASin (Math Transform)\n\n    Inputs:\n        real: (any ndarray)\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_37ASIN = {"ASIN", (PyCFunction)__pyx_pw_5talib_7_ta_lib_37ASIN, METH_O, __pyx_doc_5talib_7_ta_lib_36ASIN};
-static PyObject *__pyx_pw_5talib_7_ta_lib_37ASIN(PyObject *__pyx_self, PyObject *__pyx_v_real) {
-  PyObject *__pyx_r = 0;
+static npy_intp __pyx_f_5talib_7_ta_lib_check_length4(PyArrayObject *__pyx_v_a1, PyArrayObject *__pyx_v_a2, PyArrayObject *__pyx_v_a3, PyArrayObject *__pyx_v_a4) {
+  npy_intp __pyx_v_length;
+  npy_intp __pyx_r;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("ASIN (wrapper)", 0);
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(2, 437, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_36ASIN(__pyx_self, ((PyArrayObject *)__pyx_v_real));
+  int __pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  size_t __pyx_t_5;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("check_length4", 0);
 
-  /* function exit code */
-  goto __pyx_L0;
-  __pyx_L1_error:;
-  __pyx_r = NULL;
-  __pyx_L0:;
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_a1)[0]);
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_36ASIN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) {
-  npy_intp __pyx_v_length;
-  int __pyx_v_begidx;
-  int __pyx_v_endidx;
-  int __pyx_v_lookback;
-  TA_RetCode __pyx_v_retCode;
-  int __pyx_v_outbegidx;
-  int __pyx_v_outnbelement;
-  PyArrayObject *__pyx_v_outreal = 0;
-  PyObject *__pyx_r = NULL;
-  __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
-  npy_int __pyx_t_2;
-  __Pyx_RefNannySetupContext("ASIN", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_real);
+  __pyx_t_1 = (__pyx_v_length != (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_a2)[0]));
+  if (unlikely(__pyx_t_1)) {
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 454, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
+    __pyx_t_3 = NULL;
+    __Pyx_INCREF((PyObject *)(((PyTypeObject*)PyExc_Exception)));
+    __pyx_t_4 = ((PyObject *)(((PyTypeObject*)PyExc_Exception))); 
+    __pyx_t_5 = 1;
+    {
+      PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_mstate_global->__pyx_kp_u_input_array_lengths_are_differen};
+      __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 52, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+    }
+    __Pyx_Raise(__pyx_t_2, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __PYX_ERR(4, 52, __pyx_L1_error)
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  }
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_v_real->data)); if (unlikely(__pyx_t_2 == ((npy_int)-1))) __PYX_ERR(2, 456, __pyx_L1_error)
-  __pyx_v_begidx = __pyx_t_2;
+  __pyx_t_1 = (__pyx_v_length != (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_a3)[0]));
+  if (unlikely(__pyx_t_1)) {
 
-  __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
+    __pyx_t_4 = NULL;
+    __Pyx_INCREF((PyObject *)(((PyTypeObject*)PyExc_Exception)));
+    __pyx_t_3 = ((PyObject *)(((PyTypeObject*)PyExc_Exception))); 
+    __pyx_t_5 = 1;
+    {
+      PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_input_array_lengths_are_differen};
+      __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 54, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+    }
+    __Pyx_Raise(__pyx_t_2, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __PYX_ERR(4, 54, __pyx_L1_error)
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_ASIN_Lookback());
+  }
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 459, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
-  __pyx_t_1 = 0;
+  __pyx_t_1 = (__pyx_v_length != (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_a4)[0]));
+  if (unlikely(__pyx_t_1)) {
 
-  __pyx_v_retCode = TA_ASIN(0, __pyx_v_endidx, (((double *)__pyx_v_real->data) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_v_outreal->data) + __pyx_v_lookback));
+    __pyx_t_3 = NULL;
+    __Pyx_INCREF((PyObject *)(((PyTypeObject*)PyExc_Exception)));
+    __pyx_t_4 = ((PyObject *)(((PyTypeObject*)PyExc_Exception))); 
+    __pyx_t_5 = 1;
+    {
+      PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_mstate_global->__pyx_kp_u_input_array_lengths_are_differen};
+      __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 56, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+    }
+    __Pyx_Raise(__pyx_t_2, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __PYX_ERR(4, 56, __pyx_L1_error)
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_ASIN, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 461, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  }
 
-  __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outreal));
-  __pyx_r = ((PyObject *)__pyx_v_outreal);
+  __pyx_r = __pyx_v_length;
   goto __pyx_L0;
 
 
   /* function exit code */
   __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.ASIN", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = NULL;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_AddTraceback("talib._ta_lib.check_length4", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
-  __Pyx_XDECREF((PyObject *)__pyx_v_real);
-  __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
 
-/* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_39ATAN(PyObject *__pyx_self, PyObject *__pyx_v_real); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_38ATAN[] = " ATAN(real)\n\n    Vector Trigonometric ATan (Math Transform)\n\n    Inputs:\n        real: (any ndarray)\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_39ATAN = {"ATAN", (PyCFunction)__pyx_pw_5talib_7_ta_lib_39ATAN, METH_O, __pyx_doc_5talib_7_ta_lib_38ATAN};
-static PyObject *__pyx_pw_5talib_7_ta_lib_39ATAN(PyObject *__pyx_self, PyObject *__pyx_v_real) {
-  PyObject *__pyx_r = 0;
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("ATAN (wrapper)", 0);
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(2, 466, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_38ATAN(__pyx_self, ((PyArrayObject *)__pyx_v_real));
+static npy_int __pyx_f_5talib_7_ta_lib_check_begidx1(npy_intp __pyx_v_length, double *__pyx_v_a1) {
+  double __pyx_v_val;
+  long __pyx_v_i;
+  npy_int __pyx_r;
+  npy_intp __pyx_t_1;
+  int __pyx_t_2;
+
+  __pyx_t_1 = __pyx_v_length;
+  for (__pyx_v_i = 0; __pyx_v_i < __pyx_t_1; __pyx_v_i++) {
+
+    __pyx_v_val = (__pyx_v_a1[__pyx_v_i]);
+
+    __pyx_t_2 = (__pyx_v_val != __pyx_v_val);
+    if (__pyx_t_2) {
+
+      goto __pyx_L3_continue;
+
+    }
+
+    __pyx_r = __pyx_v_i;
+    goto __pyx_L0;
+    __pyx_L3_continue:;
+  }
+  /*else*/ {
+
+    __pyx_r = (__pyx_v_length - 1);
+    goto __pyx_L0;
+  }
+
 
   /* function exit code */
-  goto __pyx_L0;
-  __pyx_L1_error:;
-  __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_38ATAN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) {
-  npy_intp __pyx_v_length;
-  int __pyx_v_begidx;
-  int __pyx_v_endidx;
-  int __pyx_v_lookback;
-  TA_RetCode __pyx_v_retCode;
-  int __pyx_v_outbegidx;
-  int __pyx_v_outnbelement;
+
+static npy_int __pyx_f_5talib_7_ta_lib_check_begidx2(npy_intp __pyx_v_length, double *__pyx_v_a1, double *__pyx_v_a2) {
+  double __pyx_v_val;
+  long __pyx_v_i;
+  npy_int __pyx_r;
+  npy_intp __pyx_t_1;
+  int __pyx_t_2;
+
+  __pyx_t_1 = __pyx_v_length;
+  for (__pyx_v_i = 0; __pyx_v_i < __pyx_t_1; __pyx_v_i++) {
+
+    __pyx_v_val = (__pyx_v_a1[__pyx_v_i]);
+
+    __pyx_t_2 = (__pyx_v_val != __pyx_v_val);
+    if (__pyx_t_2) {
+
+      goto __pyx_L3_continue;
+
+    }
+
+    __pyx_v_val = (__pyx_v_a2[__pyx_v_i]);
+
+    __pyx_t_2 = (__pyx_v_val != __pyx_v_val);
+    if (__pyx_t_2) {
+
+      goto __pyx_L3_continue;
+
+    }
+
+    __pyx_r = __pyx_v_i;
+    goto __pyx_L0;
+    __pyx_L3_continue:;
+  }
+  /*else*/ {
+
+    __pyx_r = (__pyx_v_length - 1);
+    goto __pyx_L0;
+  }
+
+
+  /* function exit code */
+  __pyx_L0:;
+  return __pyx_r;
+}
+
+
+static npy_int __pyx_f_5talib_7_ta_lib_check_begidx3(npy_intp __pyx_v_length, double *__pyx_v_a1, double *__pyx_v_a2, double *__pyx_v_a3) {
+  double __pyx_v_val;
+  long __pyx_v_i;
+  npy_int __pyx_r;
+  npy_intp __pyx_t_1;
+  int __pyx_t_2;
+
+  __pyx_t_1 = __pyx_v_length;
+  for (__pyx_v_i = 0; __pyx_v_i < __pyx_t_1; __pyx_v_i++) {
+
+    __pyx_v_val = (__pyx_v_a1[__pyx_v_i]);
+
+    __pyx_t_2 = (__pyx_v_val != __pyx_v_val);
+    if (__pyx_t_2) {
+
+      goto __pyx_L3_continue;
+
+    }
+
+    __pyx_v_val = (__pyx_v_a2[__pyx_v_i]);
+
+    __pyx_t_2 = (__pyx_v_val != __pyx_v_val);
+    if (__pyx_t_2) {
+
+      goto __pyx_L3_continue;
+
+    }
+
+    __pyx_v_val = (__pyx_v_a3[__pyx_v_i]);
+
+    __pyx_t_2 = (__pyx_v_val != __pyx_v_val);
+    if (__pyx_t_2) {
+
+      goto __pyx_L3_continue;
+
+    }
+
+    __pyx_r = __pyx_v_i;
+    goto __pyx_L0;
+    __pyx_L3_continue:;
+  }
+  /*else*/ {
+
+    __pyx_r = (__pyx_v_length - 1);
+    goto __pyx_L0;
+  }
+
+
+  /* function exit code */
+  __pyx_L0:;
+  return __pyx_r;
+}
+
+
+static npy_int __pyx_f_5talib_7_ta_lib_check_begidx4(npy_intp __pyx_v_length, double *__pyx_v_a1, double *__pyx_v_a2, double *__pyx_v_a3, double *__pyx_v_a4) {
+  double __pyx_v_val;
+  long __pyx_v_i;
+  npy_int __pyx_r;
+  npy_intp __pyx_t_1;
+  int __pyx_t_2;
+
+  __pyx_t_1 = __pyx_v_length;
+  for (__pyx_v_i = 0; __pyx_v_i < __pyx_t_1; __pyx_v_i++) {
+
+    __pyx_v_val = (__pyx_v_a1[__pyx_v_i]);
+
+    __pyx_t_2 = (__pyx_v_val != __pyx_v_val);
+    if (__pyx_t_2) {
+
+      goto __pyx_L3_continue;
+
+    }
+
+    __pyx_v_val = (__pyx_v_a2[__pyx_v_i]);
+
+    __pyx_t_2 = (__pyx_v_val != __pyx_v_val);
+    if (__pyx_t_2) {
+
+      goto __pyx_L3_continue;
+
+    }
+
+    __pyx_v_val = (__pyx_v_a3[__pyx_v_i]);
+
+    __pyx_t_2 = (__pyx_v_val != __pyx_v_val);
+    if (__pyx_t_2) {
+
+      goto __pyx_L3_continue;
+
+    }
+
+    __pyx_v_val = (__pyx_v_a4[__pyx_v_i]);
+
+    __pyx_t_2 = (__pyx_v_val != __pyx_v_val);
+    if (__pyx_t_2) {
+
+      goto __pyx_L3_continue;
+
+    }
+
+    __pyx_r = __pyx_v_i;
+    goto __pyx_L0;
+    __pyx_L3_continue:;
+  }
+  /*else*/ {
+
+    __pyx_r = (__pyx_v_length - 1);
+    goto __pyx_L0;
+  }
+
+
+  /* function exit code */
+  __pyx_L0:;
+  return __pyx_r;
+}
+
+
+static PyArrayObject *__pyx_f_5talib_7_ta_lib_make_double_array(npy_intp __pyx_v_length, int __pyx_v_lookback) {
   PyArrayObject *__pyx_v_outreal = 0;
-  PyObject *__pyx_r = NULL;
+  double *__pyx_v_outreal_data;
+  long __pyx_v_i;
+  PyArrayObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  npy_int __pyx_t_2;
-  __Pyx_RefNannySetupContext("ATAN", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_real);
+  npy_intp __pyx_t_2;
+  int __pyx_t_3;
+  npy_intp __pyx_t_4;
+  int __pyx_t_5;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("make_double_array", 0);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 483, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)PyArray_EMPTY(1, (&__pyx_v_length), NPY_DOUBLE, NPY_ARRAY_DEFAULT)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 125, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
+  __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_v_outreal_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal));
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_v_real->data)); if (unlikely(__pyx_t_2 == ((npy_int)-1))) __PYX_ERR(2, 485, __pyx_L1_error)
-  __pyx_v_begidx = __pyx_t_2;
+  __pyx_t_2 = __pyx_v_length;
+  __pyx_t_3 = __pyx_v_lookback;
+  __pyx_t_5 = (__pyx_t_2 < __pyx_t_3);
+  if (__pyx_t_5) {
+    __pyx_t_4 = __pyx_t_2;
+  } else {
+    __pyx_t_4 = __pyx_t_3;
+  }
+  __pyx_t_2 = __pyx_t_4;
+  for (__pyx_v_i = 0; __pyx_v_i < __pyx_t_2; __pyx_v_i++) {
 
-  __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
+    (__pyx_v_outreal_data[__pyx_v_i]) = __pyx_v_5talib_7_ta_lib_NaN;
+  }
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_ATAN_Lookback());
+  __Pyx_XDECREF((PyObject *)__pyx_r);
+  __Pyx_INCREF((PyObject *)__pyx_v_outreal);
+  __pyx_r = __pyx_v_outreal;
+  goto __pyx_L0;
+
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("talib._ta_lib.make_double_array", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
+  __Pyx_XGIVEREF((PyObject *)__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+
+static PyArrayObject *__pyx_f_5talib_7_ta_lib_make_int_array(npy_intp __pyx_v_length, int __pyx_v_lookback) {
+  PyArrayObject *__pyx_v_outinteger = 0;
+  int *__pyx_v_outinteger_data;
+  long __pyx_v_i;
+  PyArrayObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  npy_intp __pyx_t_2;
+  int __pyx_t_3;
+  npy_intp __pyx_t_4;
+  int __pyx_t_5;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("make_int_array", 0);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 488, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)PyArray_EMPTY(1, (&__pyx_v_length), NPY_INT32, NPY_ARRAY_DEFAULT)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 135, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
+  __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_ATAN(0, __pyx_v_endidx, (((double *)__pyx_v_real->data) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_v_outreal->data) + __pyx_v_lookback));
+  __pyx_v_outinteger_data = ((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_ATAN, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 490, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __pyx_v_length;
+  __pyx_t_3 = __pyx_v_lookback;
+  __pyx_t_5 = (__pyx_t_2 < __pyx_t_3);
+  if (__pyx_t_5) {
+    __pyx_t_4 = __pyx_t_2;
+  } else {
+    __pyx_t_4 = __pyx_t_3;
+  }
+  __pyx_t_2 = __pyx_t_4;
+  for (__pyx_v_i = 0; __pyx_v_i < __pyx_t_2; __pyx_v_i++) {
 
-  __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outreal));
-  __pyx_r = ((PyObject *)__pyx_v_outreal);
+    (__pyx_v_outinteger_data[__pyx_v_i]) = 0;
+  }
+
+  __Pyx_XDECREF((PyObject *)__pyx_r);
+  __Pyx_INCREF((PyObject *)__pyx_v_outinteger);
+  __pyx_r = __pyx_v_outinteger;
   goto __pyx_L0;
 
 
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.ATAN", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = NULL;
+  __Pyx_AddTraceback("talib._ta_lib.make_int_array", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
-  __Pyx_XDECREF((PyObject *)__pyx_v_real);
-  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_XDECREF((PyObject *)__pyx_v_outinteger);
+  __Pyx_XGIVEREF((PyObject *)__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_41ATR(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_40ATR[] = " ATR(high, low, close[, timeperiod=?])\n\n    Average True Range (Volatility Indicators)\n\n    Inputs:\n        prices: ['high', 'low', 'close']\n    Parameters:\n        timeperiod: 14\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_41ATR = {"ATR", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_41ATR, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_40ATR};
-static PyObject *__pyx_pw_5talib_7_ta_lib_41ATR(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_19ACCBANDS(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_18ACCBANDS, "ACCBANDS(ndarray high, ndarray low, ndarray close, int timeperiod=-0x80000000)\n\nACCBANDS(high, low, close[, timeperiod=?])\n\nAcceleration Bands (Overlap Studies)\n\nInputs:\n    prices: ['high', 'low', 'close']\nParameters:\n    timeperiod: 20\nOutputs:\n    upperband\n    middleband\n    lowerband");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_19ACCBANDS = {"ACCBANDS", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_19ACCBANDS, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_18ACCBANDS};
+static PyObject *__pyx_pw_5talib_7_ta_lib_19ACCBANDS(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
   int __pyx_v_timeperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("ATR (wrapper)", 0);
+  __Pyx_RefNannySetupContext("ACCBANDS (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,&__pyx_n_s_timeperiod,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,&__pyx_mstate_global->__pyx_n_u_timeperiod,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 142, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 142, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 142, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 142, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 142, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("ATR", 0, 3, 4, 1); __PYX_ERR(2, 495, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("ATR", 0, 3, 4, 2); __PYX_ERR(2, 495, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod);
-          if (value) { values[3] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "ATR") < 0)) __PYX_ERR(2, 495, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "ACCBANDS", 0) < (0)) __PYX_ERR(4, 142, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 3; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("ACCBANDS", 0, 3, 4, i); __PYX_ERR(4, 142, __pyx_L3_error) }
       }
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 142, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 142, __pyx_L3_error)
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 142, __pyx_L3_error)
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 142, __pyx_L3_error)
         break;
         default: goto __pyx_L5_argtuple_error;
       }
@@ -7942,34 +8591,47 @@ static PyObject *__pyx_pw_5talib_7_ta_lib_41ATR(PyObject *__pyx_self, PyObject *
     __pyx_v_low = ((PyArrayObject *)values[1]);
     __pyx_v_close = ((PyArrayObject *)values[2]);
     if (values[3]) {
-      __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[3]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 495, __pyx_L3_error)
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[3]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 144, __pyx_L3_error)
     } else {
-      __pyx_v_timeperiod = ((int)-2147483648);
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
     }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("ATR", 0, 3, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 495, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("ACCBANDS", 0, 3, 4, __pyx_nargs); __PYX_ERR(4, 142, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.ATR", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.ACCBANDS", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(2, 495, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(2, 495, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(2, 495, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_40ATR(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_timeperiod);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 144, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 144, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 144, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_18ACCBANDS(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_timeperiod);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_40ATR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_18ACCBANDS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -7977,66 +8639,94 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_40ATR(CYTHON_UNUSED PyObject *__pyx_se
   TA_RetCode __pyx_v_retCode;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  PyArrayObject *__pyx_v_outreal = 0;
+  PyArrayObject *__pyx_v_outrealupperband = 0;
+  PyArrayObject *__pyx_v_outrealmiddleband = 0;
+  PyArrayObject *__pyx_v_outreallowerband = 0;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
   npy_int __pyx_t_3;
-  __Pyx_RefNannySetupContext("ATR", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("ACCBANDS", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 514, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 167, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 515, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 168, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 516, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 169, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(2, 517, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 170, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
-  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx3(__pyx_v_length, ((double *)__pyx_v_high->data), ((double *)__pyx_v_low->data), ((double *)__pyx_v_close->data)); if (unlikely(__pyx_t_3 == ((npy_int)-1))) __PYX_ERR(2, 518, __pyx_L1_error)
+  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx3(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 171, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_3;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_ATR_Lookback(__pyx_v_timeperiod));
+  __pyx_v_lookback = (__pyx_v_begidx + TA_ACCBANDS_Lookback(__pyx_v_timeperiod));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 521, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 174, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
+  __pyx_v_outrealupperband = ((PyArrayObject *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 175, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_outrealmiddleband = ((PyArrayObject *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 176, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_outreallowerband = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_ATR(0, __pyx_v_endidx, (((double *)__pyx_v_high->data) + __pyx_v_begidx), (((double *)__pyx_v_low->data) + __pyx_v_begidx), (((double *)__pyx_v_close->data) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_v_outreal->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_ACCBANDS(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outrealupperband)) + __pyx_v_lookback), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outrealmiddleband)) + __pyx_v_lookback), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreallowerband)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_ATR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 523, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_ACCBANDS, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 178, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outreal));
-  __pyx_r = ((PyObject *)__pyx_v_outreal);
+  __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 179, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_INCREF((PyObject *)__pyx_v_outrealupperband);
+  __Pyx_GIVEREF((PyObject *)__pyx_v_outrealupperband);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_outrealupperband)) != (0)) __PYX_ERR(4, 179, __pyx_L1_error);
+  __Pyx_INCREF((PyObject *)__pyx_v_outrealmiddleband);
+  __Pyx_GIVEREF((PyObject *)__pyx_v_outrealmiddleband);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, ((PyObject *)__pyx_v_outrealmiddleband)) != (0)) __PYX_ERR(4, 179, __pyx_L1_error);
+  __Pyx_INCREF((PyObject *)__pyx_v_outreallowerband);
+  __Pyx_GIVEREF((PyObject *)__pyx_v_outreallowerband);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, ((PyObject *)__pyx_v_outreallowerband)) != (0)) __PYX_ERR(4, 179, __pyx_L1_error);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
   goto __pyx_L0;
 
 
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.ATR", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.ACCBANDS", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
+  __Pyx_XDECREF((PyObject *)__pyx_v_outrealupperband);
+  __Pyx_XDECREF((PyObject *)__pyx_v_outrealmiddleband);
+  __Pyx_XDECREF((PyObject *)__pyx_v_outreallowerband);
   __Pyx_XDECREF((PyObject *)__pyx_v_high);
   __Pyx_XDECREF((PyObject *)__pyx_v_low);
   __Pyx_XDECREF((PyObject *)__pyx_v_close);
@@ -8047,99 +8737,102 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_40ATR(CYTHON_UNUSED PyObject *__pyx_se
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_43AVGPRICE(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_42AVGPRICE[] = " AVGPRICE(open, high, low, close)\n\n    Average Price (Price Transform)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_43AVGPRICE = {"AVGPRICE", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_43AVGPRICE, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_42AVGPRICE};
-static PyObject *__pyx_pw_5talib_7_ta_lib_43AVGPRICE(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_open = 0;
-  PyArrayObject *__pyx_v_high = 0;
-  PyArrayObject *__pyx_v_low = 0;
-  PyArrayObject *__pyx_v_close = 0;
+static PyObject *__pyx_pw_5talib_7_ta_lib_21ACOS(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_20ACOS, "ACOS(ndarray real)\n\nACOS(real)\n\nVector Trigonometric ACos (Math Transform)\n\nInputs:\n    real: (any ndarray)\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_21ACOS = {"ACOS", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_21ACOS, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_20ACOS};
+static PyObject *__pyx_pw_5talib_7_ta_lib_21ACOS(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_real = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("AVGPRICE (wrapper)", 0);
+  __Pyx_RefNannySetupContext("ACOS (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 181, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 181, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("AVGPRICE", 1, 4, 4, 1); __PYX_ERR(2, 528, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("AVGPRICE", 1, 4, 4, 2); __PYX_ERR(2, 528, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("AVGPRICE", 1, 4, 4, 3); __PYX_ERR(2, 528, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "AVGPRICE") < 0)) __PYX_ERR(2, 528, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "ACOS", 0) < (0)) __PYX_ERR(4, 181, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("ACOS", 1, 1, 1, i); __PYX_ERR(4, 181, __pyx_L3_error) }
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
+    } else if (unlikely(__pyx_nargs != 1)) {
       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[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 181, __pyx_L3_error)
     }
-    __pyx_v_open = ((PyArrayObject *)values[0]);
-    __pyx_v_high = ((PyArrayObject *)values[1]);
-    __pyx_v_low = ((PyArrayObject *)values[2]);
-    __pyx_v_close = ((PyArrayObject *)values[3]);
+    __pyx_v_real = ((PyArrayObject *)values[0]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("AVGPRICE", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 528, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("ACOS", 1, 1, 1, __pyx_nargs); __PYX_ERR(4, 181, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.AVGPRICE", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.ACOS", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(2, 528, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(2, 528, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(2, 528, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(2, 528, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_42AVGPRICE(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 183, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_20ACOS(__pyx_self, __pyx_v_real);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_42AVGPRICE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_20ACOS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -8151,57 +8844,40 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_42AVGPRICE(CYTHON_UNUSED PyObject *__p
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  npy_intp __pyx_t_2;
-  npy_int __pyx_t_3;
-  __Pyx_RefNannySetupContext("AVGPRICE", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_open);
-  __Pyx_INCREF((PyObject *)__pyx_v_high);
-  __Pyx_INCREF((PyObject *)__pyx_v_low);
-  __Pyx_INCREF((PyObject *)__pyx_v_close);
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 545, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 546, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 547, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
+  npy_int __pyx_t_2;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("ACOS", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 548, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 200, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(2, 549, __pyx_L1_error)
-  __pyx_v_length = __pyx_t_2;
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
-  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_v_open->data), ((double *)__pyx_v_high->data), ((double *)__pyx_v_low->data), ((double *)__pyx_v_close->data)); if (unlikely(__pyx_t_3 == ((npy_int)-1))) __PYX_ERR(2, 550, __pyx_L1_error)
-  __pyx_v_begidx = __pyx_t_3;
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 202, __pyx_L1_error)
+  __pyx_v_begidx = __pyx_t_2;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_AVGPRICE_Lookback());
+  __pyx_v_lookback = (__pyx_v_begidx + TA_ACOS_Lookback());
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 553, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 205, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_AVGPRICE(0, __pyx_v_endidx, (((double *)__pyx_v_open->data) + __pyx_v_begidx), (((double *)__pyx_v_high->data) + __pyx_v_begidx), (((double *)__pyx_v_low->data) + __pyx_v_begidx), (((double *)__pyx_v_close->data) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_v_outreal->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_ACOS(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_AVGPRICE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 555, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_ACOS, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 207, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outreal));
+  __Pyx_INCREF((PyObject *)__pyx_v_outreal);
   __pyx_r = ((PyObject *)__pyx_v_outreal);
   goto __pyx_L0;
 
@@ -8209,14 +8885,11 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_42AVGPRICE(CYTHON_UNUSED PyObject *__p
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.AVGPRICE", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.ACOS", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
-  __Pyx_XDECREF((PyObject *)__pyx_v_open);
-  __Pyx_XDECREF((PyObject *)__pyx_v_high);
-  __Pyx_XDECREF((PyObject *)__pyx_v_low);
-  __Pyx_XDECREF((PyObject *)__pyx_v_close);
+  __Pyx_XDECREF((PyObject *)__pyx_v_real);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -8224,129 +8897,129 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_42AVGPRICE(CYTHON_UNUSED PyObject *__p
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_45BBANDS(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_44BBANDS[] = " BBANDS(real[, timeperiod=?, nbdevup=?, nbdevdn=?, matype=?])\n\n    Bollinger Bands (Overlap Studies)\n\n    Inputs:\n        real: (any ndarray)\n    Parameters:\n        timeperiod: 5\n        nbdevup: 2\n        nbdevdn: 2\n        matype: 0 (Simple Moving Average)\n    Outputs:\n        upperband\n        middleband\n        lowerband\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_45BBANDS = {"BBANDS", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_45BBANDS, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_44BBANDS};
-static PyObject *__pyx_pw_5talib_7_ta_lib_45BBANDS(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_real = 0;
-  int __pyx_v_timeperiod;
-  double __pyx_v_nbdevup;
-  double __pyx_v_nbdevdn;
-  int __pyx_v_matype;
+static PyObject *__pyx_pw_5talib_7_ta_lib_23AD(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_22AD, "AD(ndarray high, ndarray low, ndarray close, ndarray volume)\n\nAD(high, low, close, volume)\n\nChaikin A/D Line (Volume Indicators)\n\nInputs:\n    prices: ['high', 'low', 'close', 'volume']\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_23AD = {"AD", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_23AD, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_22AD};
+static PyObject *__pyx_pw_5talib_7_ta_lib_23AD(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_high = 0;
+  PyArrayObject *__pyx_v_low = 0;
+  PyArrayObject *__pyx_v_close = 0;
+  PyArrayObject *__pyx_v_volume = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("BBANDS (wrapper)", 0);
+  __Pyx_RefNannySetupContext("AD (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,&__pyx_n_s_nbdevup,&__pyx_n_s_nbdevdn,&__pyx_n_s_matype,0};
-    PyObject* values[5] = {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  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
-        CYTHON_FALLTHROUGH;
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,&__pyx_mstate_global->__pyx_n_u_volume,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 210, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 210, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 210, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 210, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 210, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod);
-          if (value) { values[1] = value; kw_args--; }
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_nbdevup);
-          if (value) { values[2] = value; kw_args--; }
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_nbdevdn);
-          if (value) { values[3] = value; kw_args--; }
-        }
-        CYTHON_FALLTHROUGH;
-        case  4:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_matype);
-          if (value) { values[4] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "BBANDS") < 0)) __PYX_ERR(2, 560, __pyx_L3_error)
-      }
-    } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
-        CYTHON_FALLTHROUGH;
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-        break;
-        default: goto __pyx_L5_argtuple_error;
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "AD", 0) < (0)) __PYX_ERR(4, 210, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("AD", 1, 4, 4, i); __PYX_ERR(4, 210, __pyx_L3_error) }
       }
-    }
-    __pyx_v_real = ((PyArrayObject *)values[0]);
-    if (values[1]) {
-      __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 560, __pyx_L3_error)
-    } else {
-      __pyx_v_timeperiod = ((int)-2147483648);
-    }
-    if (values[2]) {
-      __pyx_v_nbdevup = __pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_nbdevup == (double)-1) && PyErr_Occurred())) __PYX_ERR(2, 560, __pyx_L3_error)
-    } else {
-      __pyx_v_nbdevup = ((double)-4e37);
-    }
-    if (values[3]) {
-      __pyx_v_nbdevdn = __pyx_PyFloat_AsDouble(values[3]); if (unlikely((__pyx_v_nbdevdn == (double)-1) && PyErr_Occurred())) __PYX_ERR(2, 560, __pyx_L3_error)
-    } else {
-      __pyx_v_nbdevdn = ((double)-4e37);
-    }
-    if (values[4]) {
-      __pyx_v_matype = __Pyx_PyInt_As_int(values[4]); if (unlikely((__pyx_v_matype == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 560, __pyx_L3_error)
+    } else if (unlikely(__pyx_nargs != 4)) {
+      goto __pyx_L5_argtuple_error;
     } else {
-      __pyx_v_matype = ((int)0);
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 210, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 210, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 210, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 210, __pyx_L3_error)
     }
+    __pyx_v_high = ((PyArrayObject *)values[0]);
+    __pyx_v_low = ((PyArrayObject *)values[1]);
+    __pyx_v_close = ((PyArrayObject *)values[2]);
+    __pyx_v_volume = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("BBANDS", 0, 1, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 560, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("AD", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 210, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.BBANDS", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.AD", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(2, 560, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_44BBANDS(__pyx_self, __pyx_v_real, __pyx_v_timeperiod, __pyx_v_nbdevup, __pyx_v_nbdevdn, __pyx_v_matype);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 212, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 212, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 212, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_volume), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "volume", 0))) __PYX_ERR(4, 212, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_22AD(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_volume);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_44BBANDS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod, double __pyx_v_nbdevup, double __pyx_v_nbdevdn, int __pyx_v_matype) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_22AD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, PyArrayObject *__pyx_v_volume) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -8354,78 +9027,79 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_44BBANDS(CYTHON_UNUSED PyObject *__pyx
   TA_RetCode __pyx_v_retCode;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  PyArrayObject *__pyx_v_outrealupperband = 0;
-  PyArrayObject *__pyx_v_outrealmiddleband = 0;
-  PyArrayObject *__pyx_v_outreallowerband = 0;
+  PyArrayObject *__pyx_v_outreal = 0;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  npy_int __pyx_t_2;
-  __Pyx_RefNannySetupContext("BBANDS", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_real);
+  npy_intp __pyx_t_2;
+  npy_int __pyx_t_3;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("AD", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_high);
+  __Pyx_INCREF((PyObject *)__pyx_v_low);
+  __Pyx_INCREF((PyObject *)__pyx_v_close);
+  __Pyx_INCREF((PyObject *)__pyx_v_volume);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 586, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 229, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
-
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_v_real->data)); if (unlikely(__pyx_t_2 == ((npy_int)-1))) __PYX_ERR(2, 588, __pyx_L1_error)
-  __pyx_v_begidx = __pyx_t_2;
-
-  __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
-
-  __pyx_v_lookback = (__pyx_v_begidx + TA_BBANDS_Lookback(__pyx_v_timeperiod, __pyx_v_nbdevup, __pyx_v_nbdevdn, __pyx_v_matype));
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 230, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 591, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 231, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_v_outrealupperband = ((PyArrayObject *)__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 592, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_volume)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 232, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_v_outrealmiddleband = ((PyArrayObject *)__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_volume, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 593, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_volume); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 233, __pyx_L1_error)
+  __pyx_v_length = __pyx_t_2;
+
+  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_volume))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 234, __pyx_L1_error)
+  __pyx_v_begidx = __pyx_t_3;
+
+  __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
+
+  __pyx_v_lookback = (__pyx_v_begidx + TA_AD_Lookback());
+
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 237, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_v_outreallowerband = ((PyArrayObject *)__pyx_t_1);
+  __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_BBANDS(0, __pyx_v_endidx, (((double *)__pyx_v_real->data) + __pyx_v_begidx), __pyx_v_timeperiod, __pyx_v_nbdevup, __pyx_v_nbdevdn, __pyx_v_matype, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_v_outrealupperband->data) + __pyx_v_lookback), (((double *)__pyx_v_outrealmiddleband->data) + __pyx_v_lookback), (((double *)__pyx_v_outreallowerband->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_AD(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_volume)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_BBANDS, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 595, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_AD, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 239, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 596, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outrealupperband));
-  __Pyx_GIVEREF(((PyObject *)__pyx_v_outrealupperband));
-  PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_outrealupperband));
-  __Pyx_INCREF(((PyObject *)__pyx_v_outrealmiddleband));
-  __Pyx_GIVEREF(((PyObject *)__pyx_v_outrealmiddleband));
-  PyTuple_SET_ITEM(__pyx_t_1, 1, ((PyObject *)__pyx_v_outrealmiddleband));
-  __Pyx_INCREF(((PyObject *)__pyx_v_outreallowerband));
-  __Pyx_GIVEREF(((PyObject *)__pyx_v_outreallowerband));
-  PyTuple_SET_ITEM(__pyx_t_1, 2, ((PyObject *)__pyx_v_outreallowerband));
-  __pyx_r = __pyx_t_1;
-  __pyx_t_1 = 0;
+  __Pyx_INCREF((PyObject *)__pyx_v_outreal);
+  __pyx_r = ((PyObject *)__pyx_v_outreal);
   goto __pyx_L0;
 
 
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.BBANDS", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.AD", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_outrealupperband);
-  __Pyx_XDECREF((PyObject *)__pyx_v_outrealmiddleband);
-  __Pyx_XDECREF((PyObject *)__pyx_v_outreallowerband);
-  __Pyx_XDECREF((PyObject *)__pyx_v_real);
+  __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
+  __Pyx_XDECREF((PyObject *)__pyx_v_high);
+  __Pyx_XDECREF((PyObject *)__pyx_v_low);
+  __Pyx_XDECREF((PyObject *)__pyx_v_close);
+  __Pyx_XDECREF((PyObject *)__pyx_v_volume);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -8433,93 +9107,111 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_44BBANDS(CYTHON_UNUSED PyObject *__pyx
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_47BETA(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_46BETA[] = " BETA(real0, real1[, timeperiod=?])\n\n    Beta (Statistic Functions)\n\n    Inputs:\n        real0: (any ndarray)\n        real1: (any ndarray)\n    Parameters:\n        timeperiod: 5\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_47BETA = {"BETA", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_47BETA, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_46BETA};
-static PyObject *__pyx_pw_5talib_7_ta_lib_47BETA(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_25ADD(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_24ADD, "ADD(ndarray real0, ndarray real1)\n\nADD(real0, real1)\n\nVector Arithmetic Add (Math Operators)\n\nInputs:\n    real0: (any ndarray)\n    real1: (any ndarray)\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_25ADD = {"ADD", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_25ADD, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_24ADD};
+static PyObject *__pyx_pw_5talib_7_ta_lib_25ADD(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_real0 = 0;
   PyArrayObject *__pyx_v_real1 = 0;
-  int __pyx_v_timeperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("BETA (wrapper)", 0);
+  __Pyx_RefNannySetupContext("ADD (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real0,&__pyx_n_s_real1,&__pyx_n_s_timeperiod,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);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real0,&__pyx_mstate_global->__pyx_n_u_real1,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 242, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 242, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 242, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real0)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real1)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("BETA", 0, 2, 3, 1); __PYX_ERR(2, 600, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod);
-          if (value) { values[2] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "BETA") < 0)) __PYX_ERR(2, 600, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "ADD", 0) < (0)) __PYX_ERR(4, 242, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("ADD", 1, 2, 2, i); __PYX_ERR(4, 242, __pyx_L3_error) }
       }
+    } else if (unlikely(__pyx_nargs != 2)) {
+      goto __pyx_L5_argtuple_error;
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-        break;
-        default: goto __pyx_L5_argtuple_error;
-      }
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 242, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 242, __pyx_L3_error)
     }
     __pyx_v_real0 = ((PyArrayObject *)values[0]);
     __pyx_v_real1 = ((PyArrayObject *)values[1]);
-    if (values[2]) {
-      __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 600, __pyx_L3_error)
-    } else {
-      __pyx_v_timeperiod = ((int)-2147483648);
-    }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("BETA", 0, 2, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 600, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("ADD", 1, 2, 2, __pyx_nargs); __PYX_ERR(4, 242, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.BETA", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.ADD", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real0), __pyx_ptype_5numpy_ndarray, 0, "real0", 0))) __PYX_ERR(2, 600, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real1), __pyx_ptype_5numpy_ndarray, 0, "real1", 0))) __PYX_ERR(2, 600, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_46BETA(__pyx_self, __pyx_v_real0, __pyx_v_real1, __pyx_v_timeperiod);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real0), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real0", 0))) __PYX_ERR(4, 244, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real1), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real1", 0))) __PYX_ERR(4, 244, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_24ADD(__pyx_self, __pyx_v_real0, __pyx_v_real1);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_46BETA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real0, PyArrayObject *__pyx_v_real1, int __pyx_v_timeperiod) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_24ADD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real0, PyArrayObject *__pyx_v_real1) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -8533,43 +9225,46 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_46BETA(CYTHON_UNUSED PyObject *__pyx_s
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
   npy_int __pyx_t_3;
-  __Pyx_RefNannySetupContext("BETA", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("ADD", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_real0);
   __Pyx_INCREF((PyObject *)__pyx_v_real1);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 620, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 262, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_real0, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 621, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 263, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_real1, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_real0, __pyx_v_real1); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(2, 622, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_real0, __pyx_v_real1); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 264, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
-  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx2(__pyx_v_length, ((double *)__pyx_v_real0->data), ((double *)__pyx_v_real1->data)); if (unlikely(__pyx_t_3 == ((npy_int)-1))) __PYX_ERR(2, 623, __pyx_L1_error)
+  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx2(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real0)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real1))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 265, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_3;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_BETA_Lookback(__pyx_v_timeperiod));
+  __pyx_v_lookback = (__pyx_v_begidx + TA_ADD_Lookback());
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 626, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 268, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_BETA(0, __pyx_v_endidx, (((double *)__pyx_v_real0->data) + __pyx_v_begidx), (((double *)__pyx_v_real1->data) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_v_outreal->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_ADD(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real0)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real1)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_BETA, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 628, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_ADD, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 270, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outreal));
+  __Pyx_INCREF((PyObject *)__pyx_v_outreal);
   __pyx_r = ((PyObject *)__pyx_v_outreal);
   goto __pyx_L0;
 
@@ -8577,7 +9272,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_46BETA(CYTHON_UNUSED PyObject *__pyx_s
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.BETA", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.ADD", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
@@ -8590,99 +9285,160 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_46BETA(CYTHON_UNUSED PyObject *__pyx_s
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_49BOP(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_48BOP[] = " BOP(open, high, low, close)\n\n    Balance Of Power (Momentum Indicators)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_49BOP = {"BOP", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_49BOP, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_48BOP};
-static PyObject *__pyx_pw_5talib_7_ta_lib_49BOP(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_open = 0;
+static PyObject *__pyx_pw_5talib_7_ta_lib_27ADOSC(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_26ADOSC, "ADOSC(ndarray high, ndarray low, ndarray close, ndarray volume, int fastperiod=-0x80000000, int slowperiod=-0x80000000)\n\nADOSC(high, low, close, volume[, fastperiod=?, slowperiod=?])\n\nChaikin A/D Oscillator (Volume Indicators)\n\nInputs:\n    prices: ['high', 'low', 'close', 'volume']\nParameters:\n    fastperiod: 3\n    slowperiod: 10\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_27ADOSC = {"ADOSC", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_27ADOSC, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_26ADOSC};
+static PyObject *__pyx_pw_5talib_7_ta_lib_27ADOSC(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
+  PyArrayObject *__pyx_v_volume = 0;
+  int __pyx_v_fastperiod;
+  int __pyx_v_slowperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[6] = {0,0,0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("BOP (wrapper)", 0);
+  __Pyx_RefNannySetupContext("ADOSC (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,&__pyx_mstate_global->__pyx_n_u_volume,&__pyx_mstate_global->__pyx_n_u_fastperiod,&__pyx_mstate_global->__pyx_n_u_slowperiod,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 273, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  6:
+        values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(4, 273, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  5:
+        values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(4, 273, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 273, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 273, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 273, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 273, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("BOP", 1, 4, 4, 1); __PYX_ERR(2, 633, __pyx_L3_error)
-        }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "ADOSC", 0) < (0)) __PYX_ERR(4, 273, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("ADOSC", 0, 4, 6, i); __PYX_ERR(4, 273, __pyx_L3_error) }
+      }
+    } else {
+      switch (__pyx_nargs) {
+        case  6:
+        values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(4, 273, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("BOP", 1, 4, 4, 2); __PYX_ERR(2, 633, __pyx_L3_error)
-        }
+        case  5:
+        values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(4, 273, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("BOP", 1, 4, 4, 3); __PYX_ERR(2, 633, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "BOP") < 0)) __PYX_ERR(2, 633, __pyx_L3_error)
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 273, __pyx_L3_error)
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 273, __pyx_L3_error)
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 273, __pyx_L3_error)
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 273, __pyx_L3_error)
+        break;
+        default: goto __pyx_L5_argtuple_error;
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
-      goto __pyx_L5_argtuple_error;
+    }
+    __pyx_v_high = ((PyArrayObject *)values[0]);
+    __pyx_v_low = ((PyArrayObject *)values[1]);
+    __pyx_v_close = ((PyArrayObject *)values[2]);
+    __pyx_v_volume = ((PyArrayObject *)values[3]);
+    if (values[4]) {
+      __pyx_v_fastperiod = __Pyx_PyLong_As_int(values[4]); if (unlikely((__pyx_v_fastperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 275, __pyx_L3_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);
+      __pyx_v_fastperiod = ((int)((int)-2147483648));
+    }
+    if (values[5]) {
+      __pyx_v_slowperiod = __Pyx_PyLong_As_int(values[5]); if (unlikely((__pyx_v_slowperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 275, __pyx_L3_error)
+    } else {
+      __pyx_v_slowperiod = ((int)((int)-2147483648));
     }
-    __pyx_v_open = ((PyArrayObject *)values[0]);
-    __pyx_v_high = ((PyArrayObject *)values[1]);
-    __pyx_v_low = ((PyArrayObject *)values[2]);
-    __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("BOP", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 633, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("ADOSC", 0, 4, 6, __pyx_nargs); __PYX_ERR(4, 273, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.BOP", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.ADOSC", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(2, 633, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(2, 633, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(2, 633, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(2, 633, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_48BOP(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 275, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 275, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 275, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_volume), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "volume", 0))) __PYX_ERR(4, 275, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_26ADOSC(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_volume, __pyx_v_fastperiod, __pyx_v_slowperiod);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_48BOP(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_26ADOSC(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, PyArrayObject *__pyx_v_volume, int __pyx_v_fastperiod, int __pyx_v_slowperiod) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -8696,55 +9452,58 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_48BOP(CYTHON_UNUSED PyObject *__pyx_se
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
   npy_int __pyx_t_3;
-  __Pyx_RefNannySetupContext("BOP", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_open);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("ADOSC", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
+  __Pyx_INCREF((PyObject *)__pyx_v_volume);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 650, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 651, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 295, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 652, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 296, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 653, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 297, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(2, 654, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_volume)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 298, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_volume, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
+
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_volume); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 299, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
-  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_v_open->data), ((double *)__pyx_v_high->data), ((double *)__pyx_v_low->data), ((double *)__pyx_v_close->data)); if (unlikely(__pyx_t_3 == ((npy_int)-1))) __PYX_ERR(2, 655, __pyx_L1_error)
+  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_volume))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 300, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_3;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_BOP_Lookback());
+  __pyx_v_lookback = (__pyx_v_begidx + TA_ADOSC_Lookback(__pyx_v_fastperiod, __pyx_v_slowperiod));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 658, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 303, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_BOP(0, __pyx_v_endidx, (((double *)__pyx_v_open->data) + __pyx_v_begidx), (((double *)__pyx_v_high->data) + __pyx_v_begidx), (((double *)__pyx_v_low->data) + __pyx_v_begidx), (((double *)__pyx_v_close->data) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_v_outreal->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_ADOSC(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_volume)) + __pyx_v_begidx), __pyx_v_fastperiod, __pyx_v_slowperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_BOP, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 660, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_ADOSC, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 305, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outreal));
+  __Pyx_INCREF((PyObject *)__pyx_v_outreal);
   __pyx_r = ((PyObject *)__pyx_v_outreal);
   goto __pyx_L0;
 
@@ -8752,14 +9511,14 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_48BOP(CYTHON_UNUSED PyObject *__pyx_se
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.BOP", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.ADOSC", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
-  __Pyx_XDECREF((PyObject *)__pyx_v_open);
   __Pyx_XDECREF((PyObject *)__pyx_v_high);
   __Pyx_XDECREF((PyObject *)__pyx_v_low);
   __Pyx_XDECREF((PyObject *)__pyx_v_close);
+  __Pyx_XDECREF((PyObject *)__pyx_v_volume);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -8767,69 +9526,88 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_48BOP(CYTHON_UNUSED PyObject *__pyx_se
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_51CCI(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_50CCI[] = " CCI(high, low, close[, timeperiod=?])\n\n    Commodity Channel Index (Momentum Indicators)\n\n    Inputs:\n        prices: ['high', 'low', 'close']\n    Parameters:\n        timeperiod: 14\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_51CCI = {"CCI", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_51CCI, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_50CCI};
-static PyObject *__pyx_pw_5talib_7_ta_lib_51CCI(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_29ADX(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_28ADX, "ADX(ndarray high, ndarray low, ndarray close, int timeperiod=-0x80000000)\n\nADX(high, low, close[, timeperiod=?])\n\nAverage Directional Movement Index (Momentum Indicators)\n\nInputs:\n    prices: ['high', 'low', 'close']\nParameters:\n    timeperiod: 14\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_29ADX = {"ADX", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_29ADX, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_28ADX};
+static PyObject *__pyx_pw_5talib_7_ta_lib_29ADX(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
   int __pyx_v_timeperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("CCI (wrapper)", 0);
+  __Pyx_RefNannySetupContext("ADX (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,&__pyx_n_s_timeperiod,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,&__pyx_mstate_global->__pyx_n_u_timeperiod,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 308, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 308, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 308, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 308, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 308, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CCI", 0, 3, 4, 1); __PYX_ERR(2, 665, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CCI", 0, 3, 4, 2); __PYX_ERR(2, 665, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod);
-          if (value) { values[3] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "CCI") < 0)) __PYX_ERR(2, 665, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "ADX", 0) < (0)) __PYX_ERR(4, 308, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 3; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("ADX", 0, 3, 4, i); __PYX_ERR(4, 308, __pyx_L3_error) }
       }
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 308, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 308, __pyx_L3_error)
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 308, __pyx_L3_error)
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 308, __pyx_L3_error)
         break;
         default: goto __pyx_L5_argtuple_error;
       }
@@ -8838,34 +9616,47 @@ static PyObject *__pyx_pw_5talib_7_ta_lib_51CCI(PyObject *__pyx_self, PyObject *
     __pyx_v_low = ((PyArrayObject *)values[1]);
     __pyx_v_close = ((PyArrayObject *)values[2]);
     if (values[3]) {
-      __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[3]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 665, __pyx_L3_error)
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[3]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 310, __pyx_L3_error)
     } else {
-      __pyx_v_timeperiod = ((int)-2147483648);
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
     }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("CCI", 0, 3, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 665, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("ADX", 0, 3, 4, __pyx_nargs); __PYX_ERR(4, 308, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.CCI", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.ADX", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(2, 665, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(2, 665, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(2, 665, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_50CCI(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_timeperiod);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 310, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 310, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 310, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_28ADX(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_timeperiod);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_50CCI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_28ADX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -8879,49 +9670,52 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_50CCI(CYTHON_UNUSED PyObject *__pyx_se
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
   npy_int __pyx_t_3;
-  __Pyx_RefNannySetupContext("CCI", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("ADX", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 684, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 329, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 685, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 330, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 686, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 331, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(2, 687, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 332, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
-  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx3(__pyx_v_length, ((double *)__pyx_v_high->data), ((double *)__pyx_v_low->data), ((double *)__pyx_v_close->data)); if (unlikely(__pyx_t_3 == ((npy_int)-1))) __PYX_ERR(2, 688, __pyx_L1_error)
+  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx3(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 333, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_3;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_CCI_Lookback(__pyx_v_timeperiod));
+  __pyx_v_lookback = (__pyx_v_begidx + TA_ADX_Lookback(__pyx_v_timeperiod));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 691, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 336, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_CCI(0, __pyx_v_endidx, (((double *)__pyx_v_high->data) + __pyx_v_begidx), (((double *)__pyx_v_low->data) + __pyx_v_begidx), (((double *)__pyx_v_close->data) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_v_outreal->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_ADX(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CCI, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 693, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_ADX, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 338, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outreal));
+  __Pyx_INCREF((PyObject *)__pyx_v_outreal);
   __pyx_r = ((PyObject *)__pyx_v_outreal);
   goto __pyx_L0;
 
@@ -8929,7 +9723,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_50CCI(CYTHON_UNUSED PyObject *__pyx_se
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.CCI", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.ADX", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
@@ -8943,99 +9737,137 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_50CCI(CYTHON_UNUSED PyObject *__pyx_se
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_53CDL2CROWS(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_52CDL2CROWS[] = " CDL2CROWS(open, high, low, close)\n\n    Two Crows (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_53CDL2CROWS = {"CDL2CROWS", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_53CDL2CROWS, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_52CDL2CROWS};
-static PyObject *__pyx_pw_5talib_7_ta_lib_53CDL2CROWS(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_open = 0;
+static PyObject *__pyx_pw_5talib_7_ta_lib_31ADXR(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_30ADXR, "ADXR(ndarray high, ndarray low, ndarray close, int timeperiod=-0x80000000)\n\nADXR(high, low, close[, timeperiod=?])\n\nAverage Directional Movement Index Rating (Momentum Indicators)\n\nInputs:\n    prices: ['high', 'low', 'close']\nParameters:\n    timeperiod: 14\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_31ADXR = {"ADXR", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_31ADXR, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_30ADXR};
+static PyObject *__pyx_pw_5talib_7_ta_lib_31ADXR(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
+  int __pyx_v_timeperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("CDL2CROWS (wrapper)", 0);
+  __Pyx_RefNannySetupContext("ADXR (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,&__pyx_mstate_global->__pyx_n_u_timeperiod,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 341, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 341, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 341, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 341, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 341, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDL2CROWS", 1, 4, 4, 1); __PYX_ERR(2, 698, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDL2CROWS", 1, 4, 4, 2); __PYX_ERR(2, 698, __pyx_L3_error)
-        }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "ADXR", 0) < (0)) __PYX_ERR(4, 341, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 3; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("ADXR", 0, 3, 4, i); __PYX_ERR(4, 341, __pyx_L3_error) }
+      }
+    } else {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 341, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDL2CROWS", 1, 4, 4, 3); __PYX_ERR(2, 698, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "CDL2CROWS") < 0)) __PYX_ERR(2, 698, __pyx_L3_error)
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 341, __pyx_L3_error)
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 341, __pyx_L3_error)
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 341, __pyx_L3_error)
+        break;
+        default: goto __pyx_L5_argtuple_error;
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
-      goto __pyx_L5_argtuple_error;
+    }
+    __pyx_v_high = ((PyArrayObject *)values[0]);
+    __pyx_v_low = ((PyArrayObject *)values[1]);
+    __pyx_v_close = ((PyArrayObject *)values[2]);
+    if (values[3]) {
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[3]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 343, __pyx_L3_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);
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
     }
-    __pyx_v_open = ((PyArrayObject *)values[0]);
-    __pyx_v_high = ((PyArrayObject *)values[1]);
-    __pyx_v_low = ((PyArrayObject *)values[2]);
-    __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("CDL2CROWS", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 698, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("ADXR", 0, 3, 4, __pyx_nargs); __PYX_ERR(4, 341, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.CDL2CROWS", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.ADXR", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(2, 698, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(2, 698, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(2, 698, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(2, 698, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_52CDL2CROWS(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 343, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 343, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 343, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_30ADXR(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_timeperiod);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_52CDL2CROWS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_30ADXR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -9043,73 +9875,69 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_52CDL2CROWS(CYTHON_UNUSED PyObject *__
   TA_RetCode __pyx_v_retCode;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  PyArrayObject *__pyx_v_outinteger = 0;
+  PyArrayObject *__pyx_v_outreal = 0;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
   npy_int __pyx_t_3;
-  __Pyx_RefNannySetupContext("CDL2CROWS", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_open);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("ADXR", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 715, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 716, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 362, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 717, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 363, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 718, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 364, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(2, 719, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 365, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
-  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_v_open->data), ((double *)__pyx_v_high->data), ((double *)__pyx_v_low->data), ((double *)__pyx_v_close->data)); if (unlikely(__pyx_t_3 == ((npy_int)-1))) __PYX_ERR(2, 720, __pyx_L1_error)
+  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx3(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 366, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_3;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_CDL2CROWS_Lookback());
+  __pyx_v_lookback = (__pyx_v_begidx + TA_ADXR_Lookback(__pyx_v_timeperiod));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 723, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 369, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1);
+  __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_CDL2CROWS(0, __pyx_v_endidx, (((double *)__pyx_v_open->data) + __pyx_v_begidx), (((double *)__pyx_v_high->data) + __pyx_v_begidx), (((double *)__pyx_v_low->data) + __pyx_v_begidx), (((double *)__pyx_v_close->data) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_v_outinteger->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_ADXR(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDL2CROWS, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 725, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_ADXR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 371, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outinteger));
-  __pyx_r = ((PyObject *)__pyx_v_outinteger);
+  __Pyx_INCREF((PyObject *)__pyx_v_outreal);
+  __pyx_r = ((PyObject *)__pyx_v_outreal);
   goto __pyx_L0;
 
 
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.CDL2CROWS", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.ADXR", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_outinteger);
-  __Pyx_XDECREF((PyObject *)__pyx_v_open);
+  __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
   __Pyx_XDECREF((PyObject *)__pyx_v_high);
   __Pyx_XDECREF((PyObject *)__pyx_v_low);
   __Pyx_XDECREF((PyObject *)__pyx_v_close);
@@ -9120,99 +9948,147 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_52CDL2CROWS(CYTHON_UNUSED PyObject *__
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_55CDL3BLACKCROWS(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_54CDL3BLACKCROWS[] = " CDL3BLACKCROWS(open, high, low, close)\n\n    Three Black Crows (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_55CDL3BLACKCROWS = {"CDL3BLACKCROWS", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_55CDL3BLACKCROWS, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_54CDL3BLACKCROWS};
-static PyObject *__pyx_pw_5talib_7_ta_lib_55CDL3BLACKCROWS(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_open = 0;
-  PyArrayObject *__pyx_v_high = 0;
-  PyArrayObject *__pyx_v_low = 0;
-  PyArrayObject *__pyx_v_close = 0;
+static PyObject *__pyx_pw_5talib_7_ta_lib_33APO(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_32APO, "APO(ndarray real, int fastperiod=-0x80000000, int slowperiod=-0x80000000, int matype=0)\n\nAPO(real[, fastperiod=?, slowperiod=?, matype=?])\n\nAbsolute Price Oscillator (Momentum Indicators)\n\nInputs:\n    real: (any ndarray)\nParameters:\n    fastperiod: 12\n    slowperiod: 26\n    matype: 0 (Simple Moving Average)\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_33APO = {"APO", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_33APO, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_32APO};
+static PyObject *__pyx_pw_5talib_7_ta_lib_33APO(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_real = 0;
+  int __pyx_v_fastperiod;
+  int __pyx_v_slowperiod;
+  int __pyx_v_matype;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("CDL3BLACKCROWS (wrapper)", 0);
+  __Pyx_RefNannySetupContext("APO (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_fastperiod,&__pyx_mstate_global->__pyx_n_u_slowperiod,&__pyx_mstate_global->__pyx_n_u_matype,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 374, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 374, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 374, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 374, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 374, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "APO", 0) < (0)) __PYX_ERR(4, 374, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("APO", 0, 1, 4, i); __PYX_ERR(4, 374, __pyx_L3_error) }
+      }
+    } else {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 374, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDL3BLACKCROWS", 1, 4, 4, 1); __PYX_ERR(2, 730, __pyx_L3_error)
-        }
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 374, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDL3BLACKCROWS", 1, 4, 4, 2); __PYX_ERR(2, 730, __pyx_L3_error)
-        }
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 374, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDL3BLACKCROWS", 1, 4, 4, 3); __PYX_ERR(2, 730, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "CDL3BLACKCROWS") < 0)) __PYX_ERR(2, 730, __pyx_L3_error)
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 374, __pyx_L3_error)
+        break;
+        default: goto __pyx_L5_argtuple_error;
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
-      goto __pyx_L5_argtuple_error;
+    }
+    __pyx_v_real = ((PyArrayObject *)values[0]);
+    if (values[1]) {
+      __pyx_v_fastperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_fastperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 376, __pyx_L3_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);
+      __pyx_v_fastperiod = ((int)((int)-2147483648));
+    }
+    if (values[2]) {
+      __pyx_v_slowperiod = __Pyx_PyLong_As_int(values[2]); if (unlikely((__pyx_v_slowperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 376, __pyx_L3_error)
+    } else {
+      __pyx_v_slowperiod = ((int)((int)-2147483648));
+    }
+    if (values[3]) {
+      __pyx_v_matype = __Pyx_PyLong_As_int(values[3]); if (unlikely((__pyx_v_matype == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 376, __pyx_L3_error)
+    } else {
+      __pyx_v_matype = ((int)((int)0));
     }
-    __pyx_v_open = ((PyArrayObject *)values[0]);
-    __pyx_v_high = ((PyArrayObject *)values[1]);
-    __pyx_v_low = ((PyArrayObject *)values[2]);
-    __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("CDL3BLACKCROWS", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 730, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("APO", 0, 1, 4, __pyx_nargs); __PYX_ERR(4, 374, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.CDL3BLACKCROWS", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.APO", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(2, 730, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(2, 730, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(2, 730, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(2, 730, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_54CDL3BLACKCROWS(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 376, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_32APO(__pyx_self, __pyx_v_real, __pyx_v_fastperiod, __pyx_v_slowperiod, __pyx_v_matype);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_54CDL3BLACKCROWS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_32APO(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_fastperiod, int __pyx_v_slowperiod, int __pyx_v_matype) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -9220,76 +10096,56 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_54CDL3BLACKCROWS(CYTHON_UNUSED PyObjec
   TA_RetCode __pyx_v_retCode;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  PyArrayObject *__pyx_v_outinteger = 0;
+  PyArrayObject *__pyx_v_outreal = 0;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  npy_intp __pyx_t_2;
-  npy_int __pyx_t_3;
-  __Pyx_RefNannySetupContext("CDL3BLACKCROWS", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_open);
-  __Pyx_INCREF((PyObject *)__pyx_v_high);
-  __Pyx_INCREF((PyObject *)__pyx_v_low);
-  __Pyx_INCREF((PyObject *)__pyx_v_close);
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 747, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 748, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 749, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
+  npy_int __pyx_t_2;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("APO", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 750, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 397, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(2, 751, __pyx_L1_error)
-  __pyx_v_length = __pyx_t_2;
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
-  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_v_open->data), ((double *)__pyx_v_high->data), ((double *)__pyx_v_low->data), ((double *)__pyx_v_close->data)); if (unlikely(__pyx_t_3 == ((npy_int)-1))) __PYX_ERR(2, 752, __pyx_L1_error)
-  __pyx_v_begidx = __pyx_t_3;
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 399, __pyx_L1_error)
+  __pyx_v_begidx = __pyx_t_2;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_CDL3BLACKCROWS_Lookback());
+  __pyx_v_lookback = (__pyx_v_begidx + TA_APO_Lookback(__pyx_v_fastperiod, __pyx_v_slowperiod, __pyx_v_matype));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 755, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 402, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1);
+  __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_CDL3BLACKCROWS(0, __pyx_v_endidx, (((double *)__pyx_v_open->data) + __pyx_v_begidx), (((double *)__pyx_v_high->data) + __pyx_v_begidx), (((double *)__pyx_v_low->data) + __pyx_v_begidx), (((double *)__pyx_v_close->data) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_v_outinteger->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_APO(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), __pyx_v_fastperiod, __pyx_v_slowperiod, __pyx_v_matype, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDL3BLACKCROWS, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 757, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_APO, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 404, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outinteger));
-  __pyx_r = ((PyObject *)__pyx_v_outinteger);
+  __Pyx_INCREF((PyObject *)__pyx_v_outreal);
+  __pyx_r = ((PyObject *)__pyx_v_outreal);
   goto __pyx_L0;
 
 
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.CDL3BLACKCROWS", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.APO", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_outinteger);
-  __Pyx_XDECREF((PyObject *)__pyx_v_open);
-  __Pyx_XDECREF((PyObject *)__pyx_v_high);
-  __Pyx_XDECREF((PyObject *)__pyx_v_low);
-  __Pyx_XDECREF((PyObject *)__pyx_v_close);
+  __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
+  __Pyx_XDECREF((PyObject *)__pyx_v_real);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -9297,99 +10153,128 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_54CDL3BLACKCROWS(CYTHON_UNUSED PyObjec
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_57CDL3INSIDE(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_56CDL3INSIDE[] = " CDL3INSIDE(open, high, low, close)\n\n    Three Inside Up/Down (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_57CDL3INSIDE = {"CDL3INSIDE", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_57CDL3INSIDE, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_56CDL3INSIDE};
-static PyObject *__pyx_pw_5talib_7_ta_lib_57CDL3INSIDE(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_open = 0;
+static PyObject *__pyx_pw_5talib_7_ta_lib_35AROON(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_34AROON, "AROON(ndarray high, ndarray low, int timeperiod=-0x80000000)\n\nAROON(high, low[, timeperiod=?])\n\nAroon (Momentum Indicators)\n\nInputs:\n    prices: ['high', 'low']\nParameters:\n    timeperiod: 14\nOutputs:\n    aroondown\n    aroonup");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_35AROON = {"AROON", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_35AROON, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_34AROON};
+static PyObject *__pyx_pw_5talib_7_ta_lib_35AROON(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
-  PyArrayObject *__pyx_v_close = 0;
+  int __pyx_v_timeperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[3] = {0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("CDL3INSIDE (wrapper)", 0);
+  __Pyx_RefNannySetupContext("AROON (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_timeperiod,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 407, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 407, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 407, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 407, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDL3INSIDE", 1, 4, 4, 1); __PYX_ERR(2, 762, __pyx_L3_error)
-        }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "AROON", 0) < (0)) __PYX_ERR(4, 407, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("AROON", 0, 2, 3, i); __PYX_ERR(4, 407, __pyx_L3_error) }
+      }
+    } else {
+      switch (__pyx_nargs) {
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 407, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDL3INSIDE", 1, 4, 4, 2); __PYX_ERR(2, 762, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDL3INSIDE", 1, 4, 4, 3); __PYX_ERR(2, 762, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "CDL3INSIDE") < 0)) __PYX_ERR(2, 762, __pyx_L3_error)
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 407, __pyx_L3_error)
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 407, __pyx_L3_error)
+        break;
+        default: goto __pyx_L5_argtuple_error;
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
-      goto __pyx_L5_argtuple_error;
+    }
+    __pyx_v_high = ((PyArrayObject *)values[0]);
+    __pyx_v_low = ((PyArrayObject *)values[1]);
+    if (values[2]) {
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[2]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 409, __pyx_L3_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);
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
     }
-    __pyx_v_open = ((PyArrayObject *)values[0]);
-    __pyx_v_high = ((PyArrayObject *)values[1]);
-    __pyx_v_low = ((PyArrayObject *)values[2]);
-    __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("CDL3INSIDE", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 762, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("AROON", 0, 2, 3, __pyx_nargs); __PYX_ERR(4, 407, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.CDL3INSIDE", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.AROON", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(2, 762, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(2, 762, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(2, 762, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(2, 762, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_56CDL3INSIDE(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 409, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 409, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_34AROON(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_timeperiod);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_56CDL3INSIDE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_34AROON(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, int __pyx_v_timeperiod) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -9397,76 +10282,80 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_56CDL3INSIDE(CYTHON_UNUSED PyObject *_
   TA_RetCode __pyx_v_retCode;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  PyArrayObject *__pyx_v_outinteger = 0;
+  PyArrayObject *__pyx_v_outaroondown = 0;
+  PyArrayObject *__pyx_v_outaroonup = 0;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
   npy_int __pyx_t_3;
-  __Pyx_RefNannySetupContext("CDL3INSIDE", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_open);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("AROON", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
-  __Pyx_INCREF((PyObject *)__pyx_v_close);
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 779, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 780, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 430, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 781, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 431, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 782, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(2, 783, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_high, __pyx_v_low); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 432, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
-  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_v_open->data), ((double *)__pyx_v_high->data), ((double *)__pyx_v_low->data), ((double *)__pyx_v_close->data)); if (unlikely(__pyx_t_3 == ((npy_int)-1))) __PYX_ERR(2, 784, __pyx_L1_error)
+  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx2(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 433, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_3;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_CDL3INSIDE_Lookback());
+  __pyx_v_lookback = (__pyx_v_begidx + TA_AROON_Lookback(__pyx_v_timeperiod));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 787, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 436, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1);
+  __pyx_v_outaroondown = ((PyArrayObject *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 437, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_outaroonup = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_CDL3INSIDE(0, __pyx_v_endidx, (((double *)__pyx_v_open->data) + __pyx_v_begidx), (((double *)__pyx_v_high->data) + __pyx_v_begidx), (((double *)__pyx_v_low->data) + __pyx_v_begidx), (((double *)__pyx_v_close->data) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_v_outinteger->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_AROON(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outaroondown)) + __pyx_v_lookback), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outaroonup)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDL3INSIDE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 789, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_AROON, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 439, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outinteger));
-  __pyx_r = ((PyObject *)__pyx_v_outinteger);
+  __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 440, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_INCREF((PyObject *)__pyx_v_outaroondown);
+  __Pyx_GIVEREF((PyObject *)__pyx_v_outaroondown);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_outaroondown)) != (0)) __PYX_ERR(4, 440, __pyx_L1_error);
+  __Pyx_INCREF((PyObject *)__pyx_v_outaroonup);
+  __Pyx_GIVEREF((PyObject *)__pyx_v_outaroonup);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, ((PyObject *)__pyx_v_outaroonup)) != (0)) __PYX_ERR(4, 440, __pyx_L1_error);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
   goto __pyx_L0;
 
 
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.CDL3INSIDE", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.AROON", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_outinteger);
-  __Pyx_XDECREF((PyObject *)__pyx_v_open);
+  __Pyx_XDECREF((PyObject *)__pyx_v_outaroondown);
+  __Pyx_XDECREF((PyObject *)__pyx_v_outaroonup);
   __Pyx_XDECREF((PyObject *)__pyx_v_high);
   __Pyx_XDECREF((PyObject *)__pyx_v_low);
-  __Pyx_XDECREF((PyObject *)__pyx_v_close);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -9474,99 +10363,128 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_56CDL3INSIDE(CYTHON_UNUSED PyObject *_
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_59CDL3LINESTRIKE(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_58CDL3LINESTRIKE[] = " CDL3LINESTRIKE(open, high, low, close)\n\n    Three-Line Strike  (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_59CDL3LINESTRIKE = {"CDL3LINESTRIKE", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_59CDL3LINESTRIKE, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_58CDL3LINESTRIKE};
-static PyObject *__pyx_pw_5talib_7_ta_lib_59CDL3LINESTRIKE(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_open = 0;
+static PyObject *__pyx_pw_5talib_7_ta_lib_37AROONOSC(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_36AROONOSC, "AROONOSC(ndarray high, ndarray low, int timeperiod=-0x80000000)\n\nAROONOSC(high, low[, timeperiod=?])\n\nAroon Oscillator (Momentum Indicators)\n\nInputs:\n    prices: ['high', 'low']\nParameters:\n    timeperiod: 14\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_37AROONOSC = {"AROONOSC", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_37AROONOSC, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_36AROONOSC};
+static PyObject *__pyx_pw_5talib_7_ta_lib_37AROONOSC(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
-  PyArrayObject *__pyx_v_close = 0;
+  int __pyx_v_timeperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[3] = {0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("CDL3LINESTRIKE (wrapper)", 0);
+  __Pyx_RefNannySetupContext("AROONOSC (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_timeperiod,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 442, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 442, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 442, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 442, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDL3LINESTRIKE", 1, 4, 4, 1); __PYX_ERR(2, 794, __pyx_L3_error)
-        }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "AROONOSC", 0) < (0)) __PYX_ERR(4, 442, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("AROONOSC", 0, 2, 3, i); __PYX_ERR(4, 442, __pyx_L3_error) }
+      }
+    } else {
+      switch (__pyx_nargs) {
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 442, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDL3LINESTRIKE", 1, 4, 4, 2); __PYX_ERR(2, 794, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDL3LINESTRIKE", 1, 4, 4, 3); __PYX_ERR(2, 794, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "CDL3LINESTRIKE") < 0)) __PYX_ERR(2, 794, __pyx_L3_error)
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 442, __pyx_L3_error)
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 442, __pyx_L3_error)
+        break;
+        default: goto __pyx_L5_argtuple_error;
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
-      goto __pyx_L5_argtuple_error;
+    }
+    __pyx_v_high = ((PyArrayObject *)values[0]);
+    __pyx_v_low = ((PyArrayObject *)values[1]);
+    if (values[2]) {
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[2]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 444, __pyx_L3_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);
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
     }
-    __pyx_v_open = ((PyArrayObject *)values[0]);
-    __pyx_v_high = ((PyArrayObject *)values[1]);
-    __pyx_v_low = ((PyArrayObject *)values[2]);
-    __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("CDL3LINESTRIKE", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 794, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("AROONOSC", 0, 2, 3, __pyx_nargs); __PYX_ERR(4, 442, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.CDL3LINESTRIKE", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.AROONOSC", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(2, 794, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(2, 794, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(2, 794, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(2, 794, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_58CDL3LINESTRIKE(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 444, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 444, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_36AROONOSC(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_timeperiod);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_58CDL3LINESTRIKE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_36AROONOSC(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, int __pyx_v_timeperiod) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -9574,76 +10492,65 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_58CDL3LINESTRIKE(CYTHON_UNUSED PyObjec
   TA_RetCode __pyx_v_retCode;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  PyArrayObject *__pyx_v_outinteger = 0;
+  PyArrayObject *__pyx_v_outreal = 0;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
   npy_int __pyx_t_3;
-  __Pyx_RefNannySetupContext("CDL3LINESTRIKE", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_open);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("AROONOSC", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
-  __Pyx_INCREF((PyObject *)__pyx_v_close);
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 811, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 812, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 463, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 813, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 464, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 814, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(2, 815, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_high, __pyx_v_low); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 465, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
-  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_v_open->data), ((double *)__pyx_v_high->data), ((double *)__pyx_v_low->data), ((double *)__pyx_v_close->data)); if (unlikely(__pyx_t_3 == ((npy_int)-1))) __PYX_ERR(2, 816, __pyx_L1_error)
+  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx2(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 466, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_3;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_CDL3LINESTRIKE_Lookback());
+  __pyx_v_lookback = (__pyx_v_begidx + TA_AROONOSC_Lookback(__pyx_v_timeperiod));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 819, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 469, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1);
+  __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_CDL3LINESTRIKE(0, __pyx_v_endidx, (((double *)__pyx_v_open->data) + __pyx_v_begidx), (((double *)__pyx_v_high->data) + __pyx_v_begidx), (((double *)__pyx_v_low->data) + __pyx_v_begidx), (((double *)__pyx_v_close->data) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_v_outinteger->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_AROONOSC(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDL3LINESTRIKE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 821, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_AROONOSC, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 471, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outinteger));
-  __pyx_r = ((PyObject *)__pyx_v_outinteger);
+  __Pyx_INCREF((PyObject *)__pyx_v_outreal);
+  __pyx_r = ((PyObject *)__pyx_v_outreal);
   goto __pyx_L0;
 
 
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.CDL3LINESTRIKE", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.AROONOSC", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_outinteger);
-  __Pyx_XDECREF((PyObject *)__pyx_v_open);
+  __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
   __Pyx_XDECREF((PyObject *)__pyx_v_high);
   __Pyx_XDECREF((PyObject *)__pyx_v_low);
-  __Pyx_XDECREF((PyObject *)__pyx_v_close);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -9651,99 +10558,102 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_58CDL3LINESTRIKE(CYTHON_UNUSED PyObjec
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_61CDL3OUTSIDE(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_60CDL3OUTSIDE[] = " CDL3OUTSIDE(open, high, low, close)\n\n    Three Outside Up/Down (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_61CDL3OUTSIDE = {"CDL3OUTSIDE", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_61CDL3OUTSIDE, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_60CDL3OUTSIDE};
-static PyObject *__pyx_pw_5talib_7_ta_lib_61CDL3OUTSIDE(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_open = 0;
-  PyArrayObject *__pyx_v_high = 0;
-  PyArrayObject *__pyx_v_low = 0;
-  PyArrayObject *__pyx_v_close = 0;
+static PyObject *__pyx_pw_5talib_7_ta_lib_39ASIN(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_38ASIN, "ASIN(ndarray real)\n\nASIN(real)\n\nVector Trigonometric ASin (Math Transform)\n\nInputs:\n    real: (any ndarray)\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_39ASIN = {"ASIN", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_39ASIN, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_38ASIN};
+static PyObject *__pyx_pw_5talib_7_ta_lib_39ASIN(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_real = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("CDL3OUTSIDE (wrapper)", 0);
+  __Pyx_RefNannySetupContext("ASIN (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 474, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 474, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDL3OUTSIDE", 1, 4, 4, 1); __PYX_ERR(2, 826, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDL3OUTSIDE", 1, 4, 4, 2); __PYX_ERR(2, 826, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDL3OUTSIDE", 1, 4, 4, 3); __PYX_ERR(2, 826, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "CDL3OUTSIDE") < 0)) __PYX_ERR(2, 826, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "ASIN", 0) < (0)) __PYX_ERR(4, 474, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("ASIN", 1, 1, 1, i); __PYX_ERR(4, 474, __pyx_L3_error) }
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
+    } else if (unlikely(__pyx_nargs != 1)) {
       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[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 474, __pyx_L3_error)
     }
-    __pyx_v_open = ((PyArrayObject *)values[0]);
-    __pyx_v_high = ((PyArrayObject *)values[1]);
-    __pyx_v_low = ((PyArrayObject *)values[2]);
-    __pyx_v_close = ((PyArrayObject *)values[3]);
+    __pyx_v_real = ((PyArrayObject *)values[0]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("CDL3OUTSIDE", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 826, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("ASIN", 1, 1, 1, __pyx_nargs); __PYX_ERR(4, 474, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.CDL3OUTSIDE", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.ASIN", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(2, 826, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(2, 826, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(2, 826, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(2, 826, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_60CDL3OUTSIDE(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 476, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_38ASIN(__pyx_self, __pyx_v_real);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_60CDL3OUTSIDE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_38ASIN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -9751,76 +10661,56 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_60CDL3OUTSIDE(CYTHON_UNUSED PyObject *
   TA_RetCode __pyx_v_retCode;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  PyArrayObject *__pyx_v_outinteger = 0;
+  PyArrayObject *__pyx_v_outreal = 0;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  npy_intp __pyx_t_2;
-  npy_int __pyx_t_3;
-  __Pyx_RefNannySetupContext("CDL3OUTSIDE", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_open);
-  __Pyx_INCREF((PyObject *)__pyx_v_high);
-  __Pyx_INCREF((PyObject *)__pyx_v_low);
-  __Pyx_INCREF((PyObject *)__pyx_v_close);
+  npy_int __pyx_t_2;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("ASIN", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 843, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 493, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 844, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 845, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 846, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(2, 847, __pyx_L1_error)
-  __pyx_v_length = __pyx_t_2;
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
-  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_v_open->data), ((double *)__pyx_v_high->data), ((double *)__pyx_v_low->data), ((double *)__pyx_v_close->data)); if (unlikely(__pyx_t_3 == ((npy_int)-1))) __PYX_ERR(2, 848, __pyx_L1_error)
-  __pyx_v_begidx = __pyx_t_3;
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 495, __pyx_L1_error)
+  __pyx_v_begidx = __pyx_t_2;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_CDL3OUTSIDE_Lookback());
+  __pyx_v_lookback = (__pyx_v_begidx + TA_ASIN_Lookback());
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 851, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 498, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1);
+  __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_CDL3OUTSIDE(0, __pyx_v_endidx, (((double *)__pyx_v_open->data) + __pyx_v_begidx), (((double *)__pyx_v_high->data) + __pyx_v_begidx), (((double *)__pyx_v_low->data) + __pyx_v_begidx), (((double *)__pyx_v_close->data) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_v_outinteger->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_ASIN(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDL3OUTSIDE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 853, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_ASIN, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 500, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outinteger));
-  __pyx_r = ((PyObject *)__pyx_v_outinteger);
+  __Pyx_INCREF((PyObject *)__pyx_v_outreal);
+  __pyx_r = ((PyObject *)__pyx_v_outreal);
   goto __pyx_L0;
 
 
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.CDL3OUTSIDE", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.ASIN", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_outinteger);
-  __Pyx_XDECREF((PyObject *)__pyx_v_open);
-  __Pyx_XDECREF((PyObject *)__pyx_v_high);
-  __Pyx_XDECREF((PyObject *)__pyx_v_low);
-  __Pyx_XDECREF((PyObject *)__pyx_v_close);
+  __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
+  __Pyx_XDECREF((PyObject *)__pyx_v_real);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -9828,99 +10718,102 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_60CDL3OUTSIDE(CYTHON_UNUSED PyObject *
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_63CDL3STARSINSOUTH(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_62CDL3STARSINSOUTH[] = " CDL3STARSINSOUTH(open, high, low, close)\n\n    Three Stars In The South (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_63CDL3STARSINSOUTH = {"CDL3STARSINSOUTH", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_63CDL3STARSINSOUTH, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_62CDL3STARSINSOUTH};
-static PyObject *__pyx_pw_5talib_7_ta_lib_63CDL3STARSINSOUTH(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_open = 0;
-  PyArrayObject *__pyx_v_high = 0;
-  PyArrayObject *__pyx_v_low = 0;
-  PyArrayObject *__pyx_v_close = 0;
+static PyObject *__pyx_pw_5talib_7_ta_lib_41ATAN(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_40ATAN, "ATAN(ndarray real)\n\nATAN(real)\n\nVector Trigonometric ATan (Math Transform)\n\nInputs:\n    real: (any ndarray)\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_41ATAN = {"ATAN", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_41ATAN, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_40ATAN};
+static PyObject *__pyx_pw_5talib_7_ta_lib_41ATAN(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_real = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("CDL3STARSINSOUTH (wrapper)", 0);
+  __Pyx_RefNannySetupContext("ATAN (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 503, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 503, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDL3STARSINSOUTH", 1, 4, 4, 1); __PYX_ERR(2, 858, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDL3STARSINSOUTH", 1, 4, 4, 2); __PYX_ERR(2, 858, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDL3STARSINSOUTH", 1, 4, 4, 3); __PYX_ERR(2, 858, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "CDL3STARSINSOUTH") < 0)) __PYX_ERR(2, 858, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "ATAN", 0) < (0)) __PYX_ERR(4, 503, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("ATAN", 1, 1, 1, i); __PYX_ERR(4, 503, __pyx_L3_error) }
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
+    } else if (unlikely(__pyx_nargs != 1)) {
       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[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 503, __pyx_L3_error)
     }
-    __pyx_v_open = ((PyArrayObject *)values[0]);
-    __pyx_v_high = ((PyArrayObject *)values[1]);
-    __pyx_v_low = ((PyArrayObject *)values[2]);
-    __pyx_v_close = ((PyArrayObject *)values[3]);
+    __pyx_v_real = ((PyArrayObject *)values[0]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("CDL3STARSINSOUTH", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 858, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("ATAN", 1, 1, 1, __pyx_nargs); __PYX_ERR(4, 503, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.CDL3STARSINSOUTH", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.ATAN", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(2, 858, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(2, 858, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(2, 858, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(2, 858, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_62CDL3STARSINSOUTH(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 505, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_40ATAN(__pyx_self, __pyx_v_real);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_62CDL3STARSINSOUTH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_40ATAN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -9928,76 +10821,56 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_62CDL3STARSINSOUTH(CYTHON_UNUSED PyObj
   TA_RetCode __pyx_v_retCode;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  PyArrayObject *__pyx_v_outinteger = 0;
+  PyArrayObject *__pyx_v_outreal = 0;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  npy_intp __pyx_t_2;
-  npy_int __pyx_t_3;
-  __Pyx_RefNannySetupContext("CDL3STARSINSOUTH", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_open);
-  __Pyx_INCREF((PyObject *)__pyx_v_high);
-  __Pyx_INCREF((PyObject *)__pyx_v_low);
-  __Pyx_INCREF((PyObject *)__pyx_v_close);
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 875, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 876, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 877, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
+  npy_int __pyx_t_2;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("ATAN", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 878, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 522, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(2, 879, __pyx_L1_error)
-  __pyx_v_length = __pyx_t_2;
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
-  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_v_open->data), ((double *)__pyx_v_high->data), ((double *)__pyx_v_low->data), ((double *)__pyx_v_close->data)); if (unlikely(__pyx_t_3 == ((npy_int)-1))) __PYX_ERR(2, 880, __pyx_L1_error)
-  __pyx_v_begidx = __pyx_t_3;
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 524, __pyx_L1_error)
+  __pyx_v_begidx = __pyx_t_2;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_CDL3STARSINSOUTH_Lookback());
+  __pyx_v_lookback = (__pyx_v_begidx + TA_ATAN_Lookback());
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 883, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 527, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1);
+  __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_CDL3STARSINSOUTH(0, __pyx_v_endidx, (((double *)__pyx_v_open->data) + __pyx_v_begidx), (((double *)__pyx_v_high->data) + __pyx_v_begidx), (((double *)__pyx_v_low->data) + __pyx_v_begidx), (((double *)__pyx_v_close->data) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_v_outinteger->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_ATAN(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDL3STARSINSOUTH, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 885, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_ATAN, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 529, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outinteger));
-  __pyx_r = ((PyObject *)__pyx_v_outinteger);
+  __Pyx_INCREF((PyObject *)__pyx_v_outreal);
+  __pyx_r = ((PyObject *)__pyx_v_outreal);
   goto __pyx_L0;
 
 
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.CDL3STARSINSOUTH", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.ATAN", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_outinteger);
-  __Pyx_XDECREF((PyObject *)__pyx_v_open);
-  __Pyx_XDECREF((PyObject *)__pyx_v_high);
-  __Pyx_XDECREF((PyObject *)__pyx_v_low);
-  __Pyx_XDECREF((PyObject *)__pyx_v_close);
+  __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
+  __Pyx_XDECREF((PyObject *)__pyx_v_real);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -10005,99 +10878,137 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_62CDL3STARSINSOUTH(CYTHON_UNUSED PyObj
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_65CDL3WHITESOLDIERS(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_64CDL3WHITESOLDIERS[] = " CDL3WHITESOLDIERS(open, high, low, close)\n\n    Three Advancing White Soldiers (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_65CDL3WHITESOLDIERS = {"CDL3WHITESOLDIERS", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_65CDL3WHITESOLDIERS, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_64CDL3WHITESOLDIERS};
-static PyObject *__pyx_pw_5talib_7_ta_lib_65CDL3WHITESOLDIERS(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_open = 0;
+static PyObject *__pyx_pw_5talib_7_ta_lib_43ATR(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_42ATR, "ATR(ndarray high, ndarray low, ndarray close, int timeperiod=-0x80000000)\n\nATR(high, low, close[, timeperiod=?])\n\nAverage True Range (Volatility Indicators)\n\nInputs:\n    prices: ['high', 'low', 'close']\nParameters:\n    timeperiod: 14\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_43ATR = {"ATR", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_43ATR, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_42ATR};
+static PyObject *__pyx_pw_5talib_7_ta_lib_43ATR(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
+  int __pyx_v_timeperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("CDL3WHITESOLDIERS (wrapper)", 0);
+  __Pyx_RefNannySetupContext("ATR (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,&__pyx_mstate_global->__pyx_n_u_timeperiod,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 532, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 532, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 532, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 532, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 532, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDL3WHITESOLDIERS", 1, 4, 4, 1); __PYX_ERR(2, 890, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDL3WHITESOLDIERS", 1, 4, 4, 2); __PYX_ERR(2, 890, __pyx_L3_error)
-        }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "ATR", 0) < (0)) __PYX_ERR(4, 532, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 3; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("ATR", 0, 3, 4, i); __PYX_ERR(4, 532, __pyx_L3_error) }
+      }
+    } else {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 532, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDL3WHITESOLDIERS", 1, 4, 4, 3); __PYX_ERR(2, 890, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "CDL3WHITESOLDIERS") < 0)) __PYX_ERR(2, 890, __pyx_L3_error)
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 532, __pyx_L3_error)
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 532, __pyx_L3_error)
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 532, __pyx_L3_error)
+        break;
+        default: goto __pyx_L5_argtuple_error;
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
-      goto __pyx_L5_argtuple_error;
+    }
+    __pyx_v_high = ((PyArrayObject *)values[0]);
+    __pyx_v_low = ((PyArrayObject *)values[1]);
+    __pyx_v_close = ((PyArrayObject *)values[2]);
+    if (values[3]) {
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[3]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 534, __pyx_L3_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);
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
     }
-    __pyx_v_open = ((PyArrayObject *)values[0]);
-    __pyx_v_high = ((PyArrayObject *)values[1]);
-    __pyx_v_low = ((PyArrayObject *)values[2]);
-    __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("CDL3WHITESOLDIERS", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 890, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("ATR", 0, 3, 4, __pyx_nargs); __PYX_ERR(4, 532, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.CDL3WHITESOLDIERS", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.ATR", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(2, 890, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(2, 890, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(2, 890, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(2, 890, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_64CDL3WHITESOLDIERS(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 534, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 534, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 534, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_42ATR(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_timeperiod);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_64CDL3WHITESOLDIERS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_42ATR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -10105,73 +11016,69 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_64CDL3WHITESOLDIERS(CYTHON_UNUSED PyOb
   TA_RetCode __pyx_v_retCode;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  PyArrayObject *__pyx_v_outinteger = 0;
+  PyArrayObject *__pyx_v_outreal = 0;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
   npy_int __pyx_t_3;
-  __Pyx_RefNannySetupContext("CDL3WHITESOLDIERS", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_open);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("ATR", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 907, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 908, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 553, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 909, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 554, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 910, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 555, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(2, 911, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 556, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
-  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_v_open->data), ((double *)__pyx_v_high->data), ((double *)__pyx_v_low->data), ((double *)__pyx_v_close->data)); if (unlikely(__pyx_t_3 == ((npy_int)-1))) __PYX_ERR(2, 912, __pyx_L1_error)
+  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx3(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 557, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_3;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_CDL3WHITESOLDIERS_Lookback());
+  __pyx_v_lookback = (__pyx_v_begidx + TA_ATR_Lookback(__pyx_v_timeperiod));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 915, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 560, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1);
+  __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_CDL3WHITESOLDIERS(0, __pyx_v_endidx, (((double *)__pyx_v_open->data) + __pyx_v_begidx), (((double *)__pyx_v_high->data) + __pyx_v_begidx), (((double *)__pyx_v_low->data) + __pyx_v_begidx), (((double *)__pyx_v_close->data) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_v_outinteger->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_ATR(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDL3WHITESOLDIERS, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 917, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_ATR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 562, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outinteger));
-  __pyx_r = ((PyObject *)__pyx_v_outinteger);
+  __Pyx_INCREF((PyObject *)__pyx_v_outreal);
+  __pyx_r = ((PyObject *)__pyx_v_outreal);
   goto __pyx_L0;
 
 
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.CDL3WHITESOLDIERS", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.ATR", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_outinteger);
-  __Pyx_XDECREF((PyObject *)__pyx_v_open);
+  __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
   __Pyx_XDECREF((PyObject *)__pyx_v_high);
   __Pyx_XDECREF((PyObject *)__pyx_v_low);
   __Pyx_XDECREF((PyObject *)__pyx_v_close);
@@ -10182,117 +11089,129 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_64CDL3WHITESOLDIERS(CYTHON_UNUSED PyOb
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_67CDLABANDONEDBABY(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_66CDLABANDONEDBABY[] = " CDLABANDONEDBABY(open, high, low, close[, penetration=?])\n\n    Abandoned Baby (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Parameters:\n        penetration: 0.3\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_67CDLABANDONEDBABY = {"CDLABANDONEDBABY", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_67CDLABANDONEDBABY, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_66CDLABANDONEDBABY};
-static PyObject *__pyx_pw_5talib_7_ta_lib_67CDLABANDONEDBABY(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_45AVGPRICE(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_44AVGPRICE, "AVGPRICE(ndarray open, ndarray high, ndarray low, ndarray close)\n\nAVGPRICE(open, high, low, close)\n\nAverage Price (Price Transform)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_45AVGPRICE = {"AVGPRICE", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_45AVGPRICE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_44AVGPRICE};
+static PyObject *__pyx_pw_5talib_7_ta_lib_45AVGPRICE(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_open = 0;
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
-  double __pyx_v_penetration;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("CDLABANDONEDBABY (wrapper)", 0);
+  __Pyx_RefNannySetupContext("AVGPRICE (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,&__pyx_n_s_penetration,0};
-    PyObject* values[5] = {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  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
-        CYTHON_FALLTHROUGH;
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 565, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 565, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 565, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 565, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 565, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLABANDONEDBABY", 0, 4, 5, 1); __PYX_ERR(2, 922, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLABANDONEDBABY", 0, 4, 5, 2); __PYX_ERR(2, 922, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLABANDONEDBABY", 0, 4, 5, 3); __PYX_ERR(2, 922, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  4:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_penetration);
-          if (value) { values[4] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "CDLABANDONEDBABY") < 0)) __PYX_ERR(2, 922, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "AVGPRICE", 0) < (0)) __PYX_ERR(4, 565, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("AVGPRICE", 1, 4, 4, i); __PYX_ERR(4, 565, __pyx_L3_error) }
       }
+    } else if (unlikely(__pyx_nargs != 4)) {
+      goto __pyx_L5_argtuple_error;
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
-        CYTHON_FALLTHROUGH;
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-        break;
-        default: goto __pyx_L5_argtuple_error;
-      }
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 565, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 565, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 565, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 565, __pyx_L3_error)
     }
     __pyx_v_open = ((PyArrayObject *)values[0]);
     __pyx_v_high = ((PyArrayObject *)values[1]);
     __pyx_v_low = ((PyArrayObject *)values[2]);
     __pyx_v_close = ((PyArrayObject *)values[3]);
-    if (values[4]) {
-      __pyx_v_penetration = __pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_penetration == (double)-1) && PyErr_Occurred())) __PYX_ERR(2, 922, __pyx_L3_error)
-    } else {
-      __pyx_v_penetration = ((double)0.3);
-    }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("CDLABANDONEDBABY", 0, 4, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 922, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("AVGPRICE", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 565, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.CDLABANDONEDBABY", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.AVGPRICE", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(2, 922, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(2, 922, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(2, 922, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(2, 922, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_66CDLABANDONEDBABY(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_penetration);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 567, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 567, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 567, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 567, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_44AVGPRICE(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_66CDLABANDONEDBABY(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_44AVGPRICE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -10300,72 +11219,75 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_66CDLABANDONEDBABY(CYTHON_UNUSED PyObj
   TA_RetCode __pyx_v_retCode;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  PyArrayObject *__pyx_v_outinteger = 0;
+  PyArrayObject *__pyx_v_outreal = 0;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
   npy_int __pyx_t_3;
-  __Pyx_RefNannySetupContext("CDLABANDONEDBABY", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("AVGPRICE", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_open);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 941, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 584, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 942, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 585, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 943, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 586, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 944, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 587, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(2, 945, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 588, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
-  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_v_open->data), ((double *)__pyx_v_high->data), ((double *)__pyx_v_low->data), ((double *)__pyx_v_close->data)); if (unlikely(__pyx_t_3 == ((npy_int)-1))) __PYX_ERR(2, 946, __pyx_L1_error)
+  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 589, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_3;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLABANDONEDBABY_Lookback(__pyx_v_penetration));
+  __pyx_v_lookback = (__pyx_v_begidx + TA_AVGPRICE_Lookback());
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 949, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 592, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1);
+  __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_CDLABANDONEDBABY(0, __pyx_v_endidx, (((double *)__pyx_v_open->data) + __pyx_v_begidx), (((double *)__pyx_v_high->data) + __pyx_v_begidx), (((double *)__pyx_v_low->data) + __pyx_v_begidx), (((double *)__pyx_v_close->data) + __pyx_v_begidx), __pyx_v_penetration, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_v_outinteger->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_AVGPRICE(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLABANDONEDBABY, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 951, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_AVGPRICE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 594, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outinteger));
-  __pyx_r = ((PyObject *)__pyx_v_outinteger);
+  __Pyx_INCREF((PyObject *)__pyx_v_outreal);
+  __pyx_r = ((PyObject *)__pyx_v_outreal);
   goto __pyx_L0;
 
 
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.CDLABANDONEDBABY", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.AVGPRICE", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_outinteger);
+  __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
   __Pyx_XDECREF((PyObject *)__pyx_v_open);
   __Pyx_XDECREF((PyObject *)__pyx_v_high);
   __Pyx_XDECREF((PyObject *)__pyx_v_low);
@@ -10377,99 +11299,119 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_66CDLABANDONEDBABY(CYTHON_UNUSED PyObj
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_69CDLADVANCEBLOCK(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_68CDLADVANCEBLOCK[] = " CDLADVANCEBLOCK(open, high, low, close)\n\n    Advance Block (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_69CDLADVANCEBLOCK = {"CDLADVANCEBLOCK", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_69CDLADVANCEBLOCK, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_68CDLADVANCEBLOCK};
-static PyObject *__pyx_pw_5talib_7_ta_lib_69CDLADVANCEBLOCK(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_open = 0;
-  PyArrayObject *__pyx_v_high = 0;
-  PyArrayObject *__pyx_v_low = 0;
-  PyArrayObject *__pyx_v_close = 0;
+static PyObject *__pyx_pw_5talib_7_ta_lib_47AVGDEV(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_46AVGDEV, "AVGDEV(ndarray real, int timeperiod=-0x80000000)\n\nAVGDEV(real[, timeperiod=?])\n\nAverage Deviation (Price Transform)\n\nInputs:\n    real: (any ndarray)\nParameters:\n    timeperiod: 14\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_47AVGDEV = {"AVGDEV", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_47AVGDEV, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_46AVGDEV};
+static PyObject *__pyx_pw_5talib_7_ta_lib_47AVGDEV(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_real = 0;
+  int __pyx_v_timeperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("CDLADVANCEBLOCK (wrapper)", 0);
+  __Pyx_RefNannySetupContext("AVGDEV (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 597, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 597, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 597, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLADVANCEBLOCK", 1, 4, 4, 1); __PYX_ERR(2, 956, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "AVGDEV", 0) < (0)) __PYX_ERR(4, 597, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("AVGDEV", 0, 1, 2, i); __PYX_ERR(4, 597, __pyx_L3_error) }
+      }
+    } else {
+      switch (__pyx_nargs) {
         case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLADVANCEBLOCK", 1, 4, 4, 2); __PYX_ERR(2, 956, __pyx_L3_error)
-        }
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 597, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLADVANCEBLOCK", 1, 4, 4, 3); __PYX_ERR(2, 956, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "CDLADVANCEBLOCK") < 0)) __PYX_ERR(2, 956, __pyx_L3_error)
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 597, __pyx_L3_error)
+        break;
+        default: goto __pyx_L5_argtuple_error;
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
-      goto __pyx_L5_argtuple_error;
+    }
+    __pyx_v_real = ((PyArrayObject *)values[0]);
+    if (values[1]) {
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 599, __pyx_L3_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);
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
     }
-    __pyx_v_open = ((PyArrayObject *)values[0]);
-    __pyx_v_high = ((PyArrayObject *)values[1]);
-    __pyx_v_low = ((PyArrayObject *)values[2]);
-    __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("CDLADVANCEBLOCK", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 956, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("AVGDEV", 0, 1, 2, __pyx_nargs); __PYX_ERR(4, 597, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.CDLADVANCEBLOCK", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.AVGDEV", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(2, 956, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(2, 956, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(2, 956, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(2, 956, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_68CDLADVANCEBLOCK(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 599, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_46AVGDEV(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_68CDLADVANCEBLOCK(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_46AVGDEV(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -10477,76 +11419,56 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_68CDLADVANCEBLOCK(CYTHON_UNUSED PyObje
   TA_RetCode __pyx_v_retCode;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  PyArrayObject *__pyx_v_outinteger = 0;
+  PyArrayObject *__pyx_v_outreal = 0;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  npy_intp __pyx_t_2;
-  npy_int __pyx_t_3;
-  __Pyx_RefNannySetupContext("CDLADVANCEBLOCK", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_open);
-  __Pyx_INCREF((PyObject *)__pyx_v_high);
-  __Pyx_INCREF((PyObject *)__pyx_v_low);
-  __Pyx_INCREF((PyObject *)__pyx_v_close);
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 973, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 974, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 975, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
+  npy_int __pyx_t_2;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("AVGDEV", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 976, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 618, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(2, 977, __pyx_L1_error)
-  __pyx_v_length = __pyx_t_2;
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
-  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_v_open->data), ((double *)__pyx_v_high->data), ((double *)__pyx_v_low->data), ((double *)__pyx_v_close->data)); if (unlikely(__pyx_t_3 == ((npy_int)-1))) __PYX_ERR(2, 978, __pyx_L1_error)
-  __pyx_v_begidx = __pyx_t_3;
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 620, __pyx_L1_error)
+  __pyx_v_begidx = __pyx_t_2;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLADVANCEBLOCK_Lookback());
+  __pyx_v_lookback = (__pyx_v_begidx + TA_AVGDEV_Lookback(__pyx_v_timeperiod));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 981, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 623, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1);
+  __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_CDLADVANCEBLOCK(0, __pyx_v_endidx, (((double *)__pyx_v_open->data) + __pyx_v_begidx), (((double *)__pyx_v_high->data) + __pyx_v_begidx), (((double *)__pyx_v_low->data) + __pyx_v_begidx), (((double *)__pyx_v_close->data) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_v_outinteger->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_AVGDEV(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLADVANCEBLOCK, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 983, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_AVGDEV, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 625, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outinteger));
-  __pyx_r = ((PyObject *)__pyx_v_outinteger);
+  __Pyx_INCREF((PyObject *)__pyx_v_outreal);
+  __pyx_r = ((PyObject *)__pyx_v_outreal);
   goto __pyx_L0;
 
 
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.CDLADVANCEBLOCK", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.AVGDEV", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_outinteger);
-  __Pyx_XDECREF((PyObject *)__pyx_v_open);
-  __Pyx_XDECREF((PyObject *)__pyx_v_high);
-  __Pyx_XDECREF((PyObject *)__pyx_v_low);
-  __Pyx_XDECREF((PyObject *)__pyx_v_close);
+  __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
+  __Pyx_XDECREF((PyObject *)__pyx_v_real);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -10554,99 +11476,161 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_68CDLADVANCEBLOCK(CYTHON_UNUSED PyObje
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_71CDLBELTHOLD(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_70CDLBELTHOLD[] = " CDLBELTHOLD(open, high, low, close)\n\n    Belt-hold (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_71CDLBELTHOLD = {"CDLBELTHOLD", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_71CDLBELTHOLD, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_70CDLBELTHOLD};
-static PyObject *__pyx_pw_5talib_7_ta_lib_71CDLBELTHOLD(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_open = 0;
-  PyArrayObject *__pyx_v_high = 0;
-  PyArrayObject *__pyx_v_low = 0;
-  PyArrayObject *__pyx_v_close = 0;
+static PyObject *__pyx_pw_5talib_7_ta_lib_49BBANDS(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_48BBANDS, "BBANDS(ndarray real, int timeperiod=-0x80000000, double nbdevup=-4e37, double nbdevdn=-4e37, int matype=0)\n\nBBANDS(real[, timeperiod=?, nbdevup=?, nbdevdn=?, matype=?])\n\nBollinger Bands (Overlap Studies)\n\nInputs:\n    real: (any ndarray)\nParameters:\n    timeperiod: 5\n    nbdevup: 2.0\n    nbdevdn: 2.0\n    matype: 0 (Simple Moving Average)\nOutputs:\n    upperband\n    middleband\n    lowerband");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_49BBANDS = {"BBANDS", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_49BBANDS, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_48BBANDS};
+static PyObject *__pyx_pw_5talib_7_ta_lib_49BBANDS(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_real = 0;
+  int __pyx_v_timeperiod;
+  double __pyx_v_nbdevup;
+  double __pyx_v_nbdevdn;
+  int __pyx_v_matype;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[5] = {0,0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("CDLBELTHOLD (wrapper)", 0);
+  __Pyx_RefNannySetupContext("BBANDS (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,&__pyx_mstate_global->__pyx_n_u_nbdevup,&__pyx_mstate_global->__pyx_n_u_nbdevdn,&__pyx_mstate_global->__pyx_n_u_matype,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 628, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  5:
+        values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(4, 628, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 628, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 628, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 628, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 628, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "BBANDS", 0) < (0)) __PYX_ERR(4, 628, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("BBANDS", 0, 1, 5, i); __PYX_ERR(4, 628, __pyx_L3_error) }
+      }
+    } else {
+      switch (__pyx_nargs) {
+        case  5:
+        values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(4, 628, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLBELTHOLD", 1, 4, 4, 1); __PYX_ERR(2, 988, __pyx_L3_error)
-        }
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 628, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 628, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLBELTHOLD", 1, 4, 4, 2); __PYX_ERR(2, 988, __pyx_L3_error)
-        }
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 628, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLBELTHOLD", 1, 4, 4, 3); __PYX_ERR(2, 988, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "CDLBELTHOLD") < 0)) __PYX_ERR(2, 988, __pyx_L3_error)
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 628, __pyx_L3_error)
+        break;
+        default: goto __pyx_L5_argtuple_error;
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
-      goto __pyx_L5_argtuple_error;
+    }
+    __pyx_v_real = ((PyArrayObject *)values[0]);
+    if (values[1]) {
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 630, __pyx_L3_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);
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
+    }
+    if (values[2]) {
+      __pyx_v_nbdevup = __Pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_nbdevup == (double)-1) && PyErr_Occurred())) __PYX_ERR(4, 630, __pyx_L3_error)
+    } else {
+      __pyx_v_nbdevup = ((double)((double)-4e37));
+    }
+    if (values[3]) {
+      __pyx_v_nbdevdn = __Pyx_PyFloat_AsDouble(values[3]); if (unlikely((__pyx_v_nbdevdn == (double)-1) && PyErr_Occurred())) __PYX_ERR(4, 630, __pyx_L3_error)
+    } else {
+      __pyx_v_nbdevdn = ((double)((double)-4e37));
+    }
+    if (values[4]) {
+      __pyx_v_matype = __Pyx_PyLong_As_int(values[4]); if (unlikely((__pyx_v_matype == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 630, __pyx_L3_error)
+    } else {
+      __pyx_v_matype = ((int)((int)0));
     }
-    __pyx_v_open = ((PyArrayObject *)values[0]);
-    __pyx_v_high = ((PyArrayObject *)values[1]);
-    __pyx_v_low = ((PyArrayObject *)values[2]);
-    __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("CDLBELTHOLD", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 988, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("BBANDS", 0, 1, 5, __pyx_nargs); __PYX_ERR(4, 628, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.CDLBELTHOLD", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.BBANDS", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(2, 988, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(2, 988, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(2, 988, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(2, 988, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_70CDLBELTHOLD(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 630, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_48BBANDS(__pyx_self, __pyx_v_real, __pyx_v_timeperiod, __pyx_v_nbdevup, __pyx_v_nbdevdn, __pyx_v_matype);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_70CDLBELTHOLD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_48BBANDS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod, double __pyx_v_nbdevup, double __pyx_v_nbdevdn, int __pyx_v_matype) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -10654,76 +11638,81 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_70CDLBELTHOLD(CYTHON_UNUSED PyObject *
   TA_RetCode __pyx_v_retCode;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  PyArrayObject *__pyx_v_outinteger = 0;
+  PyArrayObject *__pyx_v_outrealupperband = 0;
+  PyArrayObject *__pyx_v_outrealmiddleband = 0;
+  PyArrayObject *__pyx_v_outreallowerband = 0;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  npy_intp __pyx_t_2;
-  npy_int __pyx_t_3;
-  __Pyx_RefNannySetupContext("CDLBELTHOLD", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_open);
-  __Pyx_INCREF((PyObject *)__pyx_v_high);
-  __Pyx_INCREF((PyObject *)__pyx_v_low);
-  __Pyx_INCREF((PyObject *)__pyx_v_close);
+  npy_int __pyx_t_2;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("BBANDS", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1005, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 656, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1006, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
+
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 658, __pyx_L1_error)
+  __pyx_v_begidx = __pyx_t_2;
+
+  __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
+
+  __pyx_v_lookback = (__pyx_v_begidx + TA_BBANDS_Lookback(__pyx_v_timeperiod, __pyx_v_nbdevup, __pyx_v_nbdevdn, __pyx_v_matype));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1007, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 661, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
+  __pyx_v_outrealupperband = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1008, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 662, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
+  __pyx_v_outrealmiddleband = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(2, 1009, __pyx_L1_error)
-  __pyx_v_length = __pyx_t_2;
-
-  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_v_open->data), ((double *)__pyx_v_high->data), ((double *)__pyx_v_low->data), ((double *)__pyx_v_close->data)); if (unlikely(__pyx_t_3 == ((npy_int)-1))) __PYX_ERR(2, 1010, __pyx_L1_error)
-  __pyx_v_begidx = __pyx_t_3;
-
-  __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
-
-  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLBELTHOLD_Lookback());
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1013, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 663, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1);
+  __pyx_v_outreallowerband = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_CDLBELTHOLD(0, __pyx_v_endidx, (((double *)__pyx_v_open->data) + __pyx_v_begidx), (((double *)__pyx_v_high->data) + __pyx_v_begidx), (((double *)__pyx_v_low->data) + __pyx_v_begidx), (((double *)__pyx_v_close->data) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_v_outinteger->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_BBANDS(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), __pyx_v_timeperiod, __pyx_v_nbdevup, __pyx_v_nbdevdn, __pyx_v_matype, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outrealupperband)) + __pyx_v_lookback), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outrealmiddleband)) + __pyx_v_lookback), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreallowerband)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLBELTHOLD, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1015, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_BBANDS, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 665, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outinteger));
-  __pyx_r = ((PyObject *)__pyx_v_outinteger);
+  __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 666, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_INCREF((PyObject *)__pyx_v_outrealupperband);
+  __Pyx_GIVEREF((PyObject *)__pyx_v_outrealupperband);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_outrealupperband)) != (0)) __PYX_ERR(4, 666, __pyx_L1_error);
+  __Pyx_INCREF((PyObject *)__pyx_v_outrealmiddleband);
+  __Pyx_GIVEREF((PyObject *)__pyx_v_outrealmiddleband);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, ((PyObject *)__pyx_v_outrealmiddleband)) != (0)) __PYX_ERR(4, 666, __pyx_L1_error);
+  __Pyx_INCREF((PyObject *)__pyx_v_outreallowerband);
+  __Pyx_GIVEREF((PyObject *)__pyx_v_outreallowerband);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, ((PyObject *)__pyx_v_outreallowerband)) != (0)) __PYX_ERR(4, 666, __pyx_L1_error);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
   goto __pyx_L0;
 
 
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.CDLBELTHOLD", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.BBANDS", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_outinteger);
-  __Pyx_XDECREF((PyObject *)__pyx_v_open);
-  __Pyx_XDECREF((PyObject *)__pyx_v_high);
-  __Pyx_XDECREF((PyObject *)__pyx_v_low);
-  __Pyx_XDECREF((PyObject *)__pyx_v_close);
+  __Pyx_XDECREF((PyObject *)__pyx_v_outrealupperband);
+  __Pyx_XDECREF((PyObject *)__pyx_v_outrealmiddleband);
+  __Pyx_XDECREF((PyObject *)__pyx_v_outreallowerband);
+  __Pyx_XDECREF((PyObject *)__pyx_v_real);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -10731,99 +11720,128 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_70CDLBELTHOLD(CYTHON_UNUSED PyObject *
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_73CDLBREAKAWAY(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_72CDLBREAKAWAY[] = " CDLBREAKAWAY(open, high, low, close)\n\n    Breakaway (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_73CDLBREAKAWAY = {"CDLBREAKAWAY", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_73CDLBREAKAWAY, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_72CDLBREAKAWAY};
-static PyObject *__pyx_pw_5talib_7_ta_lib_73CDLBREAKAWAY(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_open = 0;
-  PyArrayObject *__pyx_v_high = 0;
-  PyArrayObject *__pyx_v_low = 0;
-  PyArrayObject *__pyx_v_close = 0;
+static PyObject *__pyx_pw_5talib_7_ta_lib_51BETA(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_50BETA, "BETA(ndarray real0, ndarray real1, int timeperiod=-0x80000000)\n\nBETA(real0, real1[, timeperiod=?])\n\nBeta (Statistic Functions)\n\nInputs:\n    real0: (any ndarray)\n    real1: (any ndarray)\nParameters:\n    timeperiod: 5\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_51BETA = {"BETA", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_51BETA, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_50BETA};
+static PyObject *__pyx_pw_5talib_7_ta_lib_51BETA(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_real0 = 0;
+  PyArrayObject *__pyx_v_real1 = 0;
+  int __pyx_v_timeperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[3] = {0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("CDLBREAKAWAY (wrapper)", 0);
+  __Pyx_RefNannySetupContext("BETA (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real0,&__pyx_mstate_global->__pyx_n_u_real1,&__pyx_mstate_global->__pyx_n_u_timeperiod,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 668, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 668, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 668, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 668, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLBREAKAWAY", 1, 4, 4, 1); __PYX_ERR(2, 1020, __pyx_L3_error)
-        }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "BETA", 0) < (0)) __PYX_ERR(4, 668, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("BETA", 0, 2, 3, i); __PYX_ERR(4, 668, __pyx_L3_error) }
+      }
+    } else {
+      switch (__pyx_nargs) {
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 668, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLBREAKAWAY", 1, 4, 4, 2); __PYX_ERR(2, 1020, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLBREAKAWAY", 1, 4, 4, 3); __PYX_ERR(2, 1020, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "CDLBREAKAWAY") < 0)) __PYX_ERR(2, 1020, __pyx_L3_error)
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 668, __pyx_L3_error)
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 668, __pyx_L3_error)
+        break;
+        default: goto __pyx_L5_argtuple_error;
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
-      goto __pyx_L5_argtuple_error;
+    }
+    __pyx_v_real0 = ((PyArrayObject *)values[0]);
+    __pyx_v_real1 = ((PyArrayObject *)values[1]);
+    if (values[2]) {
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[2]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 670, __pyx_L3_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);
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
     }
-    __pyx_v_open = ((PyArrayObject *)values[0]);
-    __pyx_v_high = ((PyArrayObject *)values[1]);
-    __pyx_v_low = ((PyArrayObject *)values[2]);
-    __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("CDLBREAKAWAY", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 1020, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("BETA", 0, 2, 3, __pyx_nargs); __PYX_ERR(4, 668, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.CDLBREAKAWAY", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.BETA", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(2, 1020, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(2, 1020, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(2, 1020, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(2, 1020, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_72CDLBREAKAWAY(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real0), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real0", 0))) __PYX_ERR(4, 670, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real1), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real1", 0))) __PYX_ERR(4, 670, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_50BETA(__pyx_self, __pyx_v_real0, __pyx_v_real1, __pyx_v_timeperiod);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_72CDLBREAKAWAY(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_50BETA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real0, PyArrayObject *__pyx_v_real1, int __pyx_v_timeperiod) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -10831,76 +11849,65 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_72CDLBREAKAWAY(CYTHON_UNUSED PyObject
   TA_RetCode __pyx_v_retCode;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  PyArrayObject *__pyx_v_outinteger = 0;
+  PyArrayObject *__pyx_v_outreal = 0;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
   npy_int __pyx_t_3;
-  __Pyx_RefNannySetupContext("CDLBREAKAWAY", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_open);
-  __Pyx_INCREF((PyObject *)__pyx_v_high);
-  __Pyx_INCREF((PyObject *)__pyx_v_low);
-  __Pyx_INCREF((PyObject *)__pyx_v_close);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("BETA", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_real0);
+  __Pyx_INCREF((PyObject *)__pyx_v_real1);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1037, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 690, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_real0, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1038, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 691, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_real1, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1039, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_real0, __pyx_v_real1); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 692, __pyx_L1_error)
+  __pyx_v_length = __pyx_t_2;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1040, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(2, 1041, __pyx_L1_error)
-  __pyx_v_length = __pyx_t_2;
-
-  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_v_open->data), ((double *)__pyx_v_high->data), ((double *)__pyx_v_low->data), ((double *)__pyx_v_close->data)); if (unlikely(__pyx_t_3 == ((npy_int)-1))) __PYX_ERR(2, 1042, __pyx_L1_error)
+  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx2(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real0)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real1))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 693, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_3;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLBREAKAWAY_Lookback());
+  __pyx_v_lookback = (__pyx_v_begidx + TA_BETA_Lookback(__pyx_v_timeperiod));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1045, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 696, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1);
+  __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_CDLBREAKAWAY(0, __pyx_v_endidx, (((double *)__pyx_v_open->data) + __pyx_v_begidx), (((double *)__pyx_v_high->data) + __pyx_v_begidx), (((double *)__pyx_v_low->data) + __pyx_v_begidx), (((double *)__pyx_v_close->data) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_v_outinteger->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_BETA(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real0)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real1)) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLBREAKAWAY, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1047, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_BETA, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 698, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outinteger));
-  __pyx_r = ((PyObject *)__pyx_v_outinteger);
+  __Pyx_INCREF((PyObject *)__pyx_v_outreal);
+  __pyx_r = ((PyObject *)__pyx_v_outreal);
   goto __pyx_L0;
 
 
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.CDLBREAKAWAY", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.BETA", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_outinteger);
-  __Pyx_XDECREF((PyObject *)__pyx_v_open);
-  __Pyx_XDECREF((PyObject *)__pyx_v_high);
-  __Pyx_XDECREF((PyObject *)__pyx_v_low);
-  __Pyx_XDECREF((PyObject *)__pyx_v_close);
+  __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
+  __Pyx_XDECREF((PyObject *)__pyx_v_real0);
+  __Pyx_XDECREF((PyObject *)__pyx_v_real1);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -10908,99 +11915,129 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_72CDLBREAKAWAY(CYTHON_UNUSED PyObject
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_75CDLCLOSINGMARUBOZU(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_74CDLCLOSINGMARUBOZU[] = " CDLCLOSINGMARUBOZU(open, high, low, close)\n\n    Closing Marubozu (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_75CDLCLOSINGMARUBOZU = {"CDLCLOSINGMARUBOZU", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_75CDLCLOSINGMARUBOZU, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_74CDLCLOSINGMARUBOZU};
-static PyObject *__pyx_pw_5talib_7_ta_lib_75CDLCLOSINGMARUBOZU(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_53BOP(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_52BOP, "BOP(ndarray open, ndarray high, ndarray low, ndarray close)\n\nBOP(open, high, low, close)\n\nBalance Of Power (Momentum Indicators)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_53BOP = {"BOP", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_53BOP, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_52BOP};
+static PyObject *__pyx_pw_5talib_7_ta_lib_53BOP(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_open = 0;
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("CDLCLOSINGMARUBOZU (wrapper)", 0);
+  __Pyx_RefNannySetupContext("BOP (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 701, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 701, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 701, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 701, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 701, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLCLOSINGMARUBOZU", 1, 4, 4, 1); __PYX_ERR(2, 1052, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLCLOSINGMARUBOZU", 1, 4, 4, 2); __PYX_ERR(2, 1052, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLCLOSINGMARUBOZU", 1, 4, 4, 3); __PYX_ERR(2, 1052, __pyx_L3_error)
-        }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "BOP", 0) < (0)) __PYX_ERR(4, 701, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("BOP", 1, 4, 4, i); __PYX_ERR(4, 701, __pyx_L3_error) }
       }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "CDLCLOSINGMARUBOZU") < 0)) __PYX_ERR(2, 1052, __pyx_L3_error)
-      }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
+    } else if (unlikely(__pyx_nargs != 4)) {
       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[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 701, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 701, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 701, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 701, __pyx_L3_error)
     }
     __pyx_v_open = ((PyArrayObject *)values[0]);
     __pyx_v_high = ((PyArrayObject *)values[1]);
     __pyx_v_low = ((PyArrayObject *)values[2]);
     __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("CDLCLOSINGMARUBOZU", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 1052, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("BOP", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 701, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.CDLCLOSINGMARUBOZU", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.BOP", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(2, 1052, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(2, 1052, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(2, 1052, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(2, 1052, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_74CDLCLOSINGMARUBOZU(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 703, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 703, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 703, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 703, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_52BOP(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_74CDLCLOSINGMARUBOZU(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_52BOP(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -11008,72 +12045,75 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_74CDLCLOSINGMARUBOZU(CYTHON_UNUSED PyO
   TA_RetCode __pyx_v_retCode;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  PyArrayObject *__pyx_v_outinteger = 0;
+  PyArrayObject *__pyx_v_outreal = 0;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
   npy_int __pyx_t_3;
-  __Pyx_RefNannySetupContext("CDLCLOSINGMARUBOZU", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("BOP", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_open);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1069, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 720, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1070, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 721, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1071, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 722, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1072, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 723, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(2, 1073, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 724, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
-  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_v_open->data), ((double *)__pyx_v_high->data), ((double *)__pyx_v_low->data), ((double *)__pyx_v_close->data)); if (unlikely(__pyx_t_3 == ((npy_int)-1))) __PYX_ERR(2, 1074, __pyx_L1_error)
+  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 725, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_3;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLCLOSINGMARUBOZU_Lookback());
+  __pyx_v_lookback = (__pyx_v_begidx + TA_BOP_Lookback());
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1077, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 728, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1);
+  __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_CDLCLOSINGMARUBOZU(0, __pyx_v_endidx, (((double *)__pyx_v_open->data) + __pyx_v_begidx), (((double *)__pyx_v_high->data) + __pyx_v_begidx), (((double *)__pyx_v_low->data) + __pyx_v_begidx), (((double *)__pyx_v_close->data) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_v_outinteger->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_BOP(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLCLOSINGMARUBOZU, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1079, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_BOP, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 730, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outinteger));
-  __pyx_r = ((PyObject *)__pyx_v_outinteger);
+  __Pyx_INCREF((PyObject *)__pyx_v_outreal);
+  __pyx_r = ((PyObject *)__pyx_v_outreal);
   goto __pyx_L0;
 
 
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.CDLCLOSINGMARUBOZU", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.BOP", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_outinteger);
+  __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
   __Pyx_XDECREF((PyObject *)__pyx_v_open);
   __Pyx_XDECREF((PyObject *)__pyx_v_high);
   __Pyx_XDECREF((PyObject *)__pyx_v_low);
@@ -11085,99 +12125,137 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_74CDLCLOSINGMARUBOZU(CYTHON_UNUSED PyO
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_77CDLCONCEALBABYSWALL(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_76CDLCONCEALBABYSWALL[] = " CDLCONCEALBABYSWALL(open, high, low, close)\n\n    Concealing Baby Swallow (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_77CDLCONCEALBABYSWALL = {"CDLCONCEALBABYSWALL", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_77CDLCONCEALBABYSWALL, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_76CDLCONCEALBABYSWALL};
-static PyObject *__pyx_pw_5talib_7_ta_lib_77CDLCONCEALBABYSWALL(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_open = 0;
+static PyObject *__pyx_pw_5talib_7_ta_lib_55CCI(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_54CCI, "CCI(ndarray high, ndarray low, ndarray close, int timeperiod=-0x80000000)\n\nCCI(high, low, close[, timeperiod=?])\n\nCommodity Channel Index (Momentum Indicators)\n\nInputs:\n    prices: ['high', 'low', 'close']\nParameters:\n    timeperiod: 14\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_55CCI = {"CCI", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_55CCI, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_54CCI};
+static PyObject *__pyx_pw_5talib_7_ta_lib_55CCI(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
+  int __pyx_v_timeperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("CDLCONCEALBABYSWALL (wrapper)", 0);
+  __Pyx_RefNannySetupContext("CCI (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,&__pyx_mstate_global->__pyx_n_u_timeperiod,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 733, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 733, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 733, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 733, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 733, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLCONCEALBABYSWALL", 1, 4, 4, 1); __PYX_ERR(2, 1084, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLCONCEALBABYSWALL", 1, 4, 4, 2); __PYX_ERR(2, 1084, __pyx_L3_error)
-        }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CCI", 0) < (0)) __PYX_ERR(4, 733, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 3; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CCI", 0, 3, 4, i); __PYX_ERR(4, 733, __pyx_L3_error) }
+      }
+    } else {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 733, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLCONCEALBABYSWALL", 1, 4, 4, 3); __PYX_ERR(2, 1084, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "CDLCONCEALBABYSWALL") < 0)) __PYX_ERR(2, 1084, __pyx_L3_error)
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 733, __pyx_L3_error)
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 733, __pyx_L3_error)
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 733, __pyx_L3_error)
+        break;
+        default: goto __pyx_L5_argtuple_error;
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
-      goto __pyx_L5_argtuple_error;
+    }
+    __pyx_v_high = ((PyArrayObject *)values[0]);
+    __pyx_v_low = ((PyArrayObject *)values[1]);
+    __pyx_v_close = ((PyArrayObject *)values[2]);
+    if (values[3]) {
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[3]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 735, __pyx_L3_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);
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
     }
-    __pyx_v_open = ((PyArrayObject *)values[0]);
-    __pyx_v_high = ((PyArrayObject *)values[1]);
-    __pyx_v_low = ((PyArrayObject *)values[2]);
-    __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("CDLCONCEALBABYSWALL", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 1084, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("CCI", 0, 3, 4, __pyx_nargs); __PYX_ERR(4, 733, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.CDLCONCEALBABYSWALL", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.CCI", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(2, 1084, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(2, 1084, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(2, 1084, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(2, 1084, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_76CDLCONCEALBABYSWALL(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 735, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 735, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 735, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_54CCI(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_timeperiod);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_76CDLCONCEALBABYSWALL(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_54CCI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -11185,73 +12263,69 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_76CDLCONCEALBABYSWALL(CYTHON_UNUSED Py
   TA_RetCode __pyx_v_retCode;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  PyArrayObject *__pyx_v_outinteger = 0;
+  PyArrayObject *__pyx_v_outreal = 0;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
   npy_int __pyx_t_3;
-  __Pyx_RefNannySetupContext("CDLCONCEALBABYSWALL", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_open);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("CCI", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1101, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1102, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 754, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1103, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 755, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1104, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 756, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(2, 1105, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 757, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
-  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_v_open->data), ((double *)__pyx_v_high->data), ((double *)__pyx_v_low->data), ((double *)__pyx_v_close->data)); if (unlikely(__pyx_t_3 == ((npy_int)-1))) __PYX_ERR(2, 1106, __pyx_L1_error)
+  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx3(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 758, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_3;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLCONCEALBABYSWALL_Lookback());
+  __pyx_v_lookback = (__pyx_v_begidx + TA_CCI_Lookback(__pyx_v_timeperiod));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1109, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 761, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1);
+  __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_CDLCONCEALBABYSWALL(0, __pyx_v_endidx, (((double *)__pyx_v_open->data) + __pyx_v_begidx), (((double *)__pyx_v_high->data) + __pyx_v_begidx), (((double *)__pyx_v_low->data) + __pyx_v_begidx), (((double *)__pyx_v_close->data) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_v_outinteger->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_CCI(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLCONCEALBABYSWALL, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1111, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CCI, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 763, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outinteger));
-  __pyx_r = ((PyObject *)__pyx_v_outinteger);
+  __Pyx_INCREF((PyObject *)__pyx_v_outreal);
+  __pyx_r = ((PyObject *)__pyx_v_outreal);
   goto __pyx_L0;
 
 
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.CDLCONCEALBABYSWALL", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.CCI", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_outinteger);
-  __Pyx_XDECREF((PyObject *)__pyx_v_open);
+  __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
   __Pyx_XDECREF((PyObject *)__pyx_v_high);
   __Pyx_XDECREF((PyObject *)__pyx_v_low);
   __Pyx_XDECREF((PyObject *)__pyx_v_close);
@@ -11262,99 +12336,129 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_76CDLCONCEALBABYSWALL(CYTHON_UNUSED Py
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_79CDLCOUNTERATTACK(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_78CDLCOUNTERATTACK[] = " CDLCOUNTERATTACK(open, high, low, close)\n\n    Counterattack (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_79CDLCOUNTERATTACK = {"CDLCOUNTERATTACK", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_79CDLCOUNTERATTACK, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_78CDLCOUNTERATTACK};
-static PyObject *__pyx_pw_5talib_7_ta_lib_79CDLCOUNTERATTACK(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_57CDL2CROWS(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_56CDL2CROWS, "CDL2CROWS(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDL2CROWS(open, high, low, close)\n\nTwo Crows (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_57CDL2CROWS = {"CDL2CROWS", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_57CDL2CROWS, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_56CDL2CROWS};
+static PyObject *__pyx_pw_5talib_7_ta_lib_57CDL2CROWS(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_open = 0;
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("CDLCOUNTERATTACK (wrapper)", 0);
+  __Pyx_RefNannySetupContext("CDL2CROWS (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 766, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 766, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 766, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 766, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 766, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLCOUNTERATTACK", 1, 4, 4, 1); __PYX_ERR(2, 1116, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLCOUNTERATTACK", 1, 4, 4, 2); __PYX_ERR(2, 1116, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLCOUNTERATTACK", 1, 4, 4, 3); __PYX_ERR(2, 1116, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "CDLCOUNTERATTACK") < 0)) __PYX_ERR(2, 1116, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDL2CROWS", 0) < (0)) __PYX_ERR(4, 766, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDL2CROWS", 1, 4, 4, i); __PYX_ERR(4, 766, __pyx_L3_error) }
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
+    } else if (unlikely(__pyx_nargs != 4)) {
       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[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 766, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 766, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 766, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 766, __pyx_L3_error)
     }
     __pyx_v_open = ((PyArrayObject *)values[0]);
     __pyx_v_high = ((PyArrayObject *)values[1]);
     __pyx_v_low = ((PyArrayObject *)values[2]);
     __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("CDLCOUNTERATTACK", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 1116, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("CDL2CROWS", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 766, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.CDLCOUNTERATTACK", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.CDL2CROWS", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(2, 1116, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(2, 1116, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(2, 1116, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(2, 1116, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_78CDLCOUNTERATTACK(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 768, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 768, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 768, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 768, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_56CDL2CROWS(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_78CDLCOUNTERATTACK(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_56CDL2CROWS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -11368,55 +12472,58 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_78CDLCOUNTERATTACK(CYTHON_UNUSED PyObj
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
   npy_int __pyx_t_3;
-  __Pyx_RefNannySetupContext("CDLCOUNTERATTACK", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("CDL2CROWS", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_open);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1133, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 785, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1134, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 786, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1135, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 787, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1136, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 788, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(2, 1137, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 789, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
-  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_v_open->data), ((double *)__pyx_v_high->data), ((double *)__pyx_v_low->data), ((double *)__pyx_v_close->data)); if (unlikely(__pyx_t_3 == ((npy_int)-1))) __PYX_ERR(2, 1138, __pyx_L1_error)
+  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 790, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_3;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLCOUNTERATTACK_Lookback());
+  __pyx_v_lookback = (__pyx_v_begidx + TA_CDL2CROWS_Lookback());
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1141, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 793, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_CDLCOUNTERATTACK(0, __pyx_v_endidx, (((double *)__pyx_v_open->data) + __pyx_v_begidx), (((double *)__pyx_v_high->data) + __pyx_v_begidx), (((double *)__pyx_v_low->data) + __pyx_v_begidx), (((double *)__pyx_v_close->data) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_v_outinteger->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_CDL2CROWS(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLCOUNTERATTACK, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1143, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDL2CROWS, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 795, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outinteger));
+  __Pyx_INCREF((PyObject *)__pyx_v_outinteger);
   __pyx_r = ((PyObject *)__pyx_v_outinteger);
   goto __pyx_L0;
 
@@ -11424,7 +12531,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_78CDLCOUNTERATTACK(CYTHON_UNUSED PyObj
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.CDLCOUNTERATTACK", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.CDL2CROWS", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_outinteger);
@@ -11439,117 +12546,129 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_78CDLCOUNTERATTACK(CYTHON_UNUSED PyObj
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_81CDLDARKCLOUDCOVER(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_80CDLDARKCLOUDCOVER[] = " CDLDARKCLOUDCOVER(open, high, low, close[, penetration=?])\n\n    Dark Cloud Cover (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Parameters:\n        penetration: 0.5\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_81CDLDARKCLOUDCOVER = {"CDLDARKCLOUDCOVER", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_81CDLDARKCLOUDCOVER, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_80CDLDARKCLOUDCOVER};
-static PyObject *__pyx_pw_5talib_7_ta_lib_81CDLDARKCLOUDCOVER(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_59CDL3BLACKCROWS(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_58CDL3BLACKCROWS, "CDL3BLACKCROWS(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDL3BLACKCROWS(open, high, low, close)\n\nThree Black Crows (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_59CDL3BLACKCROWS = {"CDL3BLACKCROWS", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_59CDL3BLACKCROWS, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_58CDL3BLACKCROWS};
+static PyObject *__pyx_pw_5talib_7_ta_lib_59CDL3BLACKCROWS(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_open = 0;
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
-  double __pyx_v_penetration;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("CDLDARKCLOUDCOVER (wrapper)", 0);
+  __Pyx_RefNannySetupContext("CDL3BLACKCROWS (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,&__pyx_n_s_penetration,0};
-    PyObject* values[5] = {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  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
-        CYTHON_FALLTHROUGH;
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 798, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 798, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 798, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 798, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 798, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLDARKCLOUDCOVER", 0, 4, 5, 1); __PYX_ERR(2, 1148, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLDARKCLOUDCOVER", 0, 4, 5, 2); __PYX_ERR(2, 1148, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLDARKCLOUDCOVER", 0, 4, 5, 3); __PYX_ERR(2, 1148, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  4:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_penetration);
-          if (value) { values[4] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "CDLDARKCLOUDCOVER") < 0)) __PYX_ERR(2, 1148, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDL3BLACKCROWS", 0) < (0)) __PYX_ERR(4, 798, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDL3BLACKCROWS", 1, 4, 4, i); __PYX_ERR(4, 798, __pyx_L3_error) }
       }
+    } else if (unlikely(__pyx_nargs != 4)) {
+      goto __pyx_L5_argtuple_error;
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
-        CYTHON_FALLTHROUGH;
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-        break;
-        default: goto __pyx_L5_argtuple_error;
-      }
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 798, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 798, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 798, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 798, __pyx_L3_error)
     }
     __pyx_v_open = ((PyArrayObject *)values[0]);
     __pyx_v_high = ((PyArrayObject *)values[1]);
     __pyx_v_low = ((PyArrayObject *)values[2]);
     __pyx_v_close = ((PyArrayObject *)values[3]);
-    if (values[4]) {
-      __pyx_v_penetration = __pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_penetration == (double)-1) && PyErr_Occurred())) __PYX_ERR(2, 1148, __pyx_L3_error)
-    } else {
-      __pyx_v_penetration = ((double)0.5);
-    }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("CDLDARKCLOUDCOVER", 0, 4, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 1148, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("CDL3BLACKCROWS", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 798, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.CDLDARKCLOUDCOVER", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.CDL3BLACKCROWS", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(2, 1148, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(2, 1148, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(2, 1148, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(2, 1148, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_80CDLDARKCLOUDCOVER(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_penetration);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 800, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 800, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 800, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 800, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_58CDL3BLACKCROWS(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_80CDLDARKCLOUDCOVER(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_58CDL3BLACKCROWS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -11563,55 +12682,58 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_80CDLDARKCLOUDCOVER(CYTHON_UNUSED PyOb
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
   npy_int __pyx_t_3;
-  __Pyx_RefNannySetupContext("CDLDARKCLOUDCOVER", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("CDL3BLACKCROWS", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_open);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1167, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 817, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1168, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 818, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1169, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 819, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1170, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 820, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(2, 1171, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 821, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
-  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_v_open->data), ((double *)__pyx_v_high->data), ((double *)__pyx_v_low->data), ((double *)__pyx_v_close->data)); if (unlikely(__pyx_t_3 == ((npy_int)-1))) __PYX_ERR(2, 1172, __pyx_L1_error)
+  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 822, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_3;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLDARKCLOUDCOVER_Lookback(__pyx_v_penetration));
+  __pyx_v_lookback = (__pyx_v_begidx + TA_CDL3BLACKCROWS_Lookback());
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1175, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 825, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_CDLDARKCLOUDCOVER(0, __pyx_v_endidx, (((double *)__pyx_v_open->data) + __pyx_v_begidx), (((double *)__pyx_v_high->data) + __pyx_v_begidx), (((double *)__pyx_v_low->data) + __pyx_v_begidx), (((double *)__pyx_v_close->data) + __pyx_v_begidx), __pyx_v_penetration, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_v_outinteger->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_CDL3BLACKCROWS(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLDARKCLOUDCOVER, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1177, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDL3BLACKCROWS, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 827, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outinteger));
+  __Pyx_INCREF((PyObject *)__pyx_v_outinteger);
   __pyx_r = ((PyObject *)__pyx_v_outinteger);
   goto __pyx_L0;
 
@@ -11619,7 +12741,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_80CDLDARKCLOUDCOVER(CYTHON_UNUSED PyOb
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.CDLDARKCLOUDCOVER", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.CDL3BLACKCROWS", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_outinteger);
@@ -11634,99 +12756,129 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_80CDLDARKCLOUDCOVER(CYTHON_UNUSED PyOb
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_83CDLDOJI(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_82CDLDOJI[] = " CDLDOJI(open, high, low, close)\n\n    Doji (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_83CDLDOJI = {"CDLDOJI", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_83CDLDOJI, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_82CDLDOJI};
-static PyObject *__pyx_pw_5talib_7_ta_lib_83CDLDOJI(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_61CDL3INSIDE(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_60CDL3INSIDE, "CDL3INSIDE(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDL3INSIDE(open, high, low, close)\n\nThree Inside Up/Down (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_61CDL3INSIDE = {"CDL3INSIDE", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_61CDL3INSIDE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_60CDL3INSIDE};
+static PyObject *__pyx_pw_5talib_7_ta_lib_61CDL3INSIDE(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_open = 0;
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("CDLDOJI (wrapper)", 0);
+  __Pyx_RefNannySetupContext("CDL3INSIDE (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 830, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 830, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 830, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 830, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 830, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLDOJI", 1, 4, 4, 1); __PYX_ERR(2, 1182, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLDOJI", 1, 4, 4, 2); __PYX_ERR(2, 1182, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLDOJI", 1, 4, 4, 3); __PYX_ERR(2, 1182, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "CDLDOJI") < 0)) __PYX_ERR(2, 1182, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDL3INSIDE", 0) < (0)) __PYX_ERR(4, 830, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDL3INSIDE", 1, 4, 4, i); __PYX_ERR(4, 830, __pyx_L3_error) }
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
+    } else if (unlikely(__pyx_nargs != 4)) {
       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[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 830, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 830, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 830, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 830, __pyx_L3_error)
     }
     __pyx_v_open = ((PyArrayObject *)values[0]);
     __pyx_v_high = ((PyArrayObject *)values[1]);
     __pyx_v_low = ((PyArrayObject *)values[2]);
     __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("CDLDOJI", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 1182, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("CDL3INSIDE", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 830, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.CDLDOJI", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.CDL3INSIDE", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(2, 1182, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(2, 1182, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(2, 1182, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(2, 1182, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_82CDLDOJI(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 832, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 832, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 832, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 832, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_60CDL3INSIDE(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_82CDLDOJI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_60CDL3INSIDE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -11740,55 +12892,58 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_82CDLDOJI(CYTHON_UNUSED PyObject *__py
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
   npy_int __pyx_t_3;
-  __Pyx_RefNannySetupContext("CDLDOJI", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("CDL3INSIDE", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_open);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1199, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 849, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1200, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 850, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1201, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 851, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1202, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 852, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(2, 1203, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 853, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
-  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_v_open->data), ((double *)__pyx_v_high->data), ((double *)__pyx_v_low->data), ((double *)__pyx_v_close->data)); if (unlikely(__pyx_t_3 == ((npy_int)-1))) __PYX_ERR(2, 1204, __pyx_L1_error)
+  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 854, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_3;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLDOJI_Lookback());
+  __pyx_v_lookback = (__pyx_v_begidx + TA_CDL3INSIDE_Lookback());
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1207, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 857, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_CDLDOJI(0, __pyx_v_endidx, (((double *)__pyx_v_open->data) + __pyx_v_begidx), (((double *)__pyx_v_high->data) + __pyx_v_begidx), (((double *)__pyx_v_low->data) + __pyx_v_begidx), (((double *)__pyx_v_close->data) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_v_outinteger->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_CDL3INSIDE(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLDOJI, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1209, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDL3INSIDE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 859, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outinteger));
+  __Pyx_INCREF((PyObject *)__pyx_v_outinteger);
   __pyx_r = ((PyObject *)__pyx_v_outinteger);
   goto __pyx_L0;
 
@@ -11796,7 +12951,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_82CDLDOJI(CYTHON_UNUSED PyObject *__py
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.CDLDOJI", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.CDL3INSIDE", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_outinteger);
@@ -11811,99 +12966,129 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_82CDLDOJI(CYTHON_UNUSED PyObject *__py
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_85CDLDOJISTAR(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_84CDLDOJISTAR[] = " CDLDOJISTAR(open, high, low, close)\n\n    Doji Star (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_85CDLDOJISTAR = {"CDLDOJISTAR", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_85CDLDOJISTAR, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_84CDLDOJISTAR};
-static PyObject *__pyx_pw_5talib_7_ta_lib_85CDLDOJISTAR(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_63CDL3LINESTRIKE(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_62CDL3LINESTRIKE, "CDL3LINESTRIKE(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDL3LINESTRIKE(open, high, low, close)\n\nThree-Line Strike  (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_63CDL3LINESTRIKE = {"CDL3LINESTRIKE", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_63CDL3LINESTRIKE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_62CDL3LINESTRIKE};
+static PyObject *__pyx_pw_5talib_7_ta_lib_63CDL3LINESTRIKE(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_open = 0;
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("CDLDOJISTAR (wrapper)", 0);
+  __Pyx_RefNannySetupContext("CDL3LINESTRIKE (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 862, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 862, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 862, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 862, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 862, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLDOJISTAR", 1, 4, 4, 1); __PYX_ERR(2, 1214, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLDOJISTAR", 1, 4, 4, 2); __PYX_ERR(2, 1214, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLDOJISTAR", 1, 4, 4, 3); __PYX_ERR(2, 1214, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "CDLDOJISTAR") < 0)) __PYX_ERR(2, 1214, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDL3LINESTRIKE", 0) < (0)) __PYX_ERR(4, 862, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDL3LINESTRIKE", 1, 4, 4, i); __PYX_ERR(4, 862, __pyx_L3_error) }
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
+    } else if (unlikely(__pyx_nargs != 4)) {
       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[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 862, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 862, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 862, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 862, __pyx_L3_error)
     }
     __pyx_v_open = ((PyArrayObject *)values[0]);
     __pyx_v_high = ((PyArrayObject *)values[1]);
     __pyx_v_low = ((PyArrayObject *)values[2]);
     __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("CDLDOJISTAR", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 1214, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("CDL3LINESTRIKE", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 862, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.CDLDOJISTAR", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.CDL3LINESTRIKE", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(2, 1214, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(2, 1214, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(2, 1214, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(2, 1214, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_84CDLDOJISTAR(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 864, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 864, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 864, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 864, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_62CDL3LINESTRIKE(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_84CDLDOJISTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_62CDL3LINESTRIKE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -11917,55 +13102,58 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_84CDLDOJISTAR(CYTHON_UNUSED PyObject *
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
   npy_int __pyx_t_3;
-  __Pyx_RefNannySetupContext("CDLDOJISTAR", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("CDL3LINESTRIKE", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_open);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1231, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 881, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1232, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 882, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1233, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 883, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1234, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 884, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(2, 1235, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 885, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
-  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_v_open->data), ((double *)__pyx_v_high->data), ((double *)__pyx_v_low->data), ((double *)__pyx_v_close->data)); if (unlikely(__pyx_t_3 == ((npy_int)-1))) __PYX_ERR(2, 1236, __pyx_L1_error)
+  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 886, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_3;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLDOJISTAR_Lookback());
+  __pyx_v_lookback = (__pyx_v_begidx + TA_CDL3LINESTRIKE_Lookback());
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1239, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 889, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_CDLDOJISTAR(0, __pyx_v_endidx, (((double *)__pyx_v_open->data) + __pyx_v_begidx), (((double *)__pyx_v_high->data) + __pyx_v_begidx), (((double *)__pyx_v_low->data) + __pyx_v_begidx), (((double *)__pyx_v_close->data) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_v_outinteger->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_CDL3LINESTRIKE(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLDOJISTAR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1241, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDL3LINESTRIKE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 891, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outinteger));
+  __Pyx_INCREF((PyObject *)__pyx_v_outinteger);
   __pyx_r = ((PyObject *)__pyx_v_outinteger);
   goto __pyx_L0;
 
@@ -11973,7 +13161,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_84CDLDOJISTAR(CYTHON_UNUSED PyObject *
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.CDLDOJISTAR", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.CDL3LINESTRIKE", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_outinteger);
@@ -11988,99 +13176,129 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_84CDLDOJISTAR(CYTHON_UNUSED PyObject *
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_87CDLDRAGONFLYDOJI(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_86CDLDRAGONFLYDOJI[] = " CDLDRAGONFLYDOJI(open, high, low, close)\n\n    Dragonfly Doji (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_87CDLDRAGONFLYDOJI = {"CDLDRAGONFLYDOJI", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_87CDLDRAGONFLYDOJI, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_86CDLDRAGONFLYDOJI};
-static PyObject *__pyx_pw_5talib_7_ta_lib_87CDLDRAGONFLYDOJI(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_65CDL3OUTSIDE(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_64CDL3OUTSIDE, "CDL3OUTSIDE(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDL3OUTSIDE(open, high, low, close)\n\nThree Outside Up/Down (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_65CDL3OUTSIDE = {"CDL3OUTSIDE", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_65CDL3OUTSIDE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_64CDL3OUTSIDE};
+static PyObject *__pyx_pw_5talib_7_ta_lib_65CDL3OUTSIDE(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_open = 0;
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("CDLDRAGONFLYDOJI (wrapper)", 0);
+  __Pyx_RefNannySetupContext("CDL3OUTSIDE (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 894, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 894, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 894, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 894, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 894, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLDRAGONFLYDOJI", 1, 4, 4, 1); __PYX_ERR(2, 1246, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLDRAGONFLYDOJI", 1, 4, 4, 2); __PYX_ERR(2, 1246, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLDRAGONFLYDOJI", 1, 4, 4, 3); __PYX_ERR(2, 1246, __pyx_L3_error)
-        }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDL3OUTSIDE", 0) < (0)) __PYX_ERR(4, 894, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDL3OUTSIDE", 1, 4, 4, i); __PYX_ERR(4, 894, __pyx_L3_error) }
       }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "CDLDRAGONFLYDOJI") < 0)) __PYX_ERR(2, 1246, __pyx_L3_error)
-      }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
+    } else if (unlikely(__pyx_nargs != 4)) {
       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[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 894, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 894, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 894, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 894, __pyx_L3_error)
     }
     __pyx_v_open = ((PyArrayObject *)values[0]);
     __pyx_v_high = ((PyArrayObject *)values[1]);
     __pyx_v_low = ((PyArrayObject *)values[2]);
     __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("CDLDRAGONFLYDOJI", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 1246, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("CDL3OUTSIDE", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 894, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.CDLDRAGONFLYDOJI", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.CDL3OUTSIDE", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(2, 1246, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(2, 1246, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(2, 1246, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(2, 1246, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_86CDLDRAGONFLYDOJI(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 896, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 896, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 896, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 896, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_64CDL3OUTSIDE(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_86CDLDRAGONFLYDOJI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_64CDL3OUTSIDE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -12094,55 +13312,58 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_86CDLDRAGONFLYDOJI(CYTHON_UNUSED PyObj
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
   npy_int __pyx_t_3;
-  __Pyx_RefNannySetupContext("CDLDRAGONFLYDOJI", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("CDL3OUTSIDE", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_open);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1263, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 913, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1264, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 914, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1265, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 915, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1266, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 916, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(2, 1267, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 917, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
-  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_v_open->data), ((double *)__pyx_v_high->data), ((double *)__pyx_v_low->data), ((double *)__pyx_v_close->data)); if (unlikely(__pyx_t_3 == ((npy_int)-1))) __PYX_ERR(2, 1268, __pyx_L1_error)
+  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 918, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_3;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLDRAGONFLYDOJI_Lookback());
+  __pyx_v_lookback = (__pyx_v_begidx + TA_CDL3OUTSIDE_Lookback());
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1271, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 921, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_CDLDRAGONFLYDOJI(0, __pyx_v_endidx, (((double *)__pyx_v_open->data) + __pyx_v_begidx), (((double *)__pyx_v_high->data) + __pyx_v_begidx), (((double *)__pyx_v_low->data) + __pyx_v_begidx), (((double *)__pyx_v_close->data) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_v_outinteger->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_CDL3OUTSIDE(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLDRAGONFLYDOJI, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1273, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDL3OUTSIDE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 923, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outinteger));
+  __Pyx_INCREF((PyObject *)__pyx_v_outinteger);
   __pyx_r = ((PyObject *)__pyx_v_outinteger);
   goto __pyx_L0;
 
@@ -12150,7 +13371,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_86CDLDRAGONFLYDOJI(CYTHON_UNUSED PyObj
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.CDLDRAGONFLYDOJI", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.CDL3OUTSIDE", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_outinteger);
@@ -12165,99 +13386,129 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_86CDLDRAGONFLYDOJI(CYTHON_UNUSED PyObj
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_89CDLENGULFING(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_88CDLENGULFING[] = " CDLENGULFING(open, high, low, close)\n\n    Engulfing Pattern (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_89CDLENGULFING = {"CDLENGULFING", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_89CDLENGULFING, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_88CDLENGULFING};
-static PyObject *__pyx_pw_5talib_7_ta_lib_89CDLENGULFING(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_67CDL3STARSINSOUTH(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_66CDL3STARSINSOUTH, "CDL3STARSINSOUTH(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDL3STARSINSOUTH(open, high, low, close)\n\nThree Stars In The South (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_67CDL3STARSINSOUTH = {"CDL3STARSINSOUTH", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_67CDL3STARSINSOUTH, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_66CDL3STARSINSOUTH};
+static PyObject *__pyx_pw_5talib_7_ta_lib_67CDL3STARSINSOUTH(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_open = 0;
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("CDLENGULFING (wrapper)", 0);
+  __Pyx_RefNannySetupContext("CDL3STARSINSOUTH (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 926, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 926, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 926, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 926, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 926, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLENGULFING", 1, 4, 4, 1); __PYX_ERR(2, 1278, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLENGULFING", 1, 4, 4, 2); __PYX_ERR(2, 1278, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLENGULFING", 1, 4, 4, 3); __PYX_ERR(2, 1278, __pyx_L3_error)
-        }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDL3STARSINSOUTH", 0) < (0)) __PYX_ERR(4, 926, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDL3STARSINSOUTH", 1, 4, 4, i); __PYX_ERR(4, 926, __pyx_L3_error) }
       }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "CDLENGULFING") < 0)) __PYX_ERR(2, 1278, __pyx_L3_error)
-      }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
+    } else if (unlikely(__pyx_nargs != 4)) {
       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[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 926, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 926, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 926, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 926, __pyx_L3_error)
     }
     __pyx_v_open = ((PyArrayObject *)values[0]);
     __pyx_v_high = ((PyArrayObject *)values[1]);
     __pyx_v_low = ((PyArrayObject *)values[2]);
     __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("CDLENGULFING", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 1278, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("CDL3STARSINSOUTH", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 926, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.CDLENGULFING", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.CDL3STARSINSOUTH", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(2, 1278, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(2, 1278, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(2, 1278, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(2, 1278, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_88CDLENGULFING(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 928, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 928, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 928, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 928, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_66CDL3STARSINSOUTH(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_88CDLENGULFING(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_66CDL3STARSINSOUTH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -12271,55 +13522,58 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_88CDLENGULFING(CYTHON_UNUSED PyObject
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
   npy_int __pyx_t_3;
-  __Pyx_RefNannySetupContext("CDLENGULFING", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("CDL3STARSINSOUTH", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_open);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1295, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 945, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1296, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 946, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1297, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 947, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1298, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 948, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(2, 1299, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 949, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
-  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_v_open->data), ((double *)__pyx_v_high->data), ((double *)__pyx_v_low->data), ((double *)__pyx_v_close->data)); if (unlikely(__pyx_t_3 == ((npy_int)-1))) __PYX_ERR(2, 1300, __pyx_L1_error)
+  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 950, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_3;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLENGULFING_Lookback());
+  __pyx_v_lookback = (__pyx_v_begidx + TA_CDL3STARSINSOUTH_Lookback());
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1303, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 953, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_CDLENGULFING(0, __pyx_v_endidx, (((double *)__pyx_v_open->data) + __pyx_v_begidx), (((double *)__pyx_v_high->data) + __pyx_v_begidx), (((double *)__pyx_v_low->data) + __pyx_v_begidx), (((double *)__pyx_v_close->data) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_v_outinteger->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_CDL3STARSINSOUTH(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLENGULFING, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1305, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDL3STARSINSOUTH, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 955, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outinteger));
+  __Pyx_INCREF((PyObject *)__pyx_v_outinteger);
   __pyx_r = ((PyObject *)__pyx_v_outinteger);
   goto __pyx_L0;
 
@@ -12327,7 +13581,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_88CDLENGULFING(CYTHON_UNUSED PyObject
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.CDLENGULFING", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.CDL3STARSINSOUTH", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_outinteger);
@@ -12342,117 +13596,129 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_88CDLENGULFING(CYTHON_UNUSED PyObject
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_91CDLEVENINGDOJISTAR(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_90CDLEVENINGDOJISTAR[] = " CDLEVENINGDOJISTAR(open, high, low, close[, penetration=?])\n\n    Evening Doji Star (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Parameters:\n        penetration: 0.3\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_91CDLEVENINGDOJISTAR = {"CDLEVENINGDOJISTAR", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_91CDLEVENINGDOJISTAR, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_90CDLEVENINGDOJISTAR};
-static PyObject *__pyx_pw_5talib_7_ta_lib_91CDLEVENINGDOJISTAR(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_69CDL3WHITESOLDIERS(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_68CDL3WHITESOLDIERS, "CDL3WHITESOLDIERS(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDL3WHITESOLDIERS(open, high, low, close)\n\nThree Advancing White Soldiers (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_69CDL3WHITESOLDIERS = {"CDL3WHITESOLDIERS", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_69CDL3WHITESOLDIERS, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_68CDL3WHITESOLDIERS};
+static PyObject *__pyx_pw_5talib_7_ta_lib_69CDL3WHITESOLDIERS(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_open = 0;
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
-  double __pyx_v_penetration;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("CDLEVENINGDOJISTAR (wrapper)", 0);
+  __Pyx_RefNannySetupContext("CDL3WHITESOLDIERS (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,&__pyx_n_s_penetration,0};
-    PyObject* values[5] = {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  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
-        CYTHON_FALLTHROUGH;
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 958, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 958, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 958, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 958, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 958, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLEVENINGDOJISTAR", 0, 4, 5, 1); __PYX_ERR(2, 1310, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLEVENINGDOJISTAR", 0, 4, 5, 2); __PYX_ERR(2, 1310, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLEVENINGDOJISTAR", 0, 4, 5, 3); __PYX_ERR(2, 1310, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  4:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_penetration);
-          if (value) { values[4] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "CDLEVENINGDOJISTAR") < 0)) __PYX_ERR(2, 1310, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDL3WHITESOLDIERS", 0) < (0)) __PYX_ERR(4, 958, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDL3WHITESOLDIERS", 1, 4, 4, i); __PYX_ERR(4, 958, __pyx_L3_error) }
       }
+    } else if (unlikely(__pyx_nargs != 4)) {
+      goto __pyx_L5_argtuple_error;
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
-        CYTHON_FALLTHROUGH;
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-        break;
-        default: goto __pyx_L5_argtuple_error;
-      }
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 958, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 958, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 958, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 958, __pyx_L3_error)
     }
     __pyx_v_open = ((PyArrayObject *)values[0]);
     __pyx_v_high = ((PyArrayObject *)values[1]);
     __pyx_v_low = ((PyArrayObject *)values[2]);
     __pyx_v_close = ((PyArrayObject *)values[3]);
-    if (values[4]) {
-      __pyx_v_penetration = __pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_penetration == (double)-1) && PyErr_Occurred())) __PYX_ERR(2, 1310, __pyx_L3_error)
-    } else {
-      __pyx_v_penetration = ((double)0.3);
-    }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("CDLEVENINGDOJISTAR", 0, 4, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 1310, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("CDL3WHITESOLDIERS", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 958, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.CDLEVENINGDOJISTAR", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.CDL3WHITESOLDIERS", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(2, 1310, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(2, 1310, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(2, 1310, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(2, 1310, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_90CDLEVENINGDOJISTAR(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_penetration);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 960, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 960, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 960, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 960, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_68CDL3WHITESOLDIERS(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_90CDLEVENINGDOJISTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_68CDL3WHITESOLDIERS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -12466,55 +13732,58 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_90CDLEVENINGDOJISTAR(CYTHON_UNUSED PyO
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
   npy_int __pyx_t_3;
-  __Pyx_RefNannySetupContext("CDLEVENINGDOJISTAR", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("CDL3WHITESOLDIERS", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_open);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1329, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 977, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1330, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 978, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1331, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 979, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1332, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 980, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(2, 1333, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 981, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
-  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_v_open->data), ((double *)__pyx_v_high->data), ((double *)__pyx_v_low->data), ((double *)__pyx_v_close->data)); if (unlikely(__pyx_t_3 == ((npy_int)-1))) __PYX_ERR(2, 1334, __pyx_L1_error)
+  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 982, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_3;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLEVENINGDOJISTAR_Lookback(__pyx_v_penetration));
+  __pyx_v_lookback = (__pyx_v_begidx + TA_CDL3WHITESOLDIERS_Lookback());
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1337, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 985, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_CDLEVENINGDOJISTAR(0, __pyx_v_endidx, (((double *)__pyx_v_open->data) + __pyx_v_begidx), (((double *)__pyx_v_high->data) + __pyx_v_begidx), (((double *)__pyx_v_low->data) + __pyx_v_begidx), (((double *)__pyx_v_close->data) + __pyx_v_begidx), __pyx_v_penetration, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_v_outinteger->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_CDL3WHITESOLDIERS(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLEVENINGDOJISTAR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1339, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDL3WHITESOLDIERS, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 987, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outinteger));
+  __Pyx_INCREF((PyObject *)__pyx_v_outinteger);
   __pyx_r = ((PyObject *)__pyx_v_outinteger);
   goto __pyx_L0;
 
@@ -12522,7 +13791,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_90CDLEVENINGDOJISTAR(CYTHON_UNUSED PyO
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.CDLEVENINGDOJISTAR", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.CDL3WHITESOLDIERS", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_outinteger);
@@ -12537,79 +13806,95 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_90CDLEVENINGDOJISTAR(CYTHON_UNUSED PyO
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_93CDLEVENINGSTAR(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_92CDLEVENINGSTAR[] = " CDLEVENINGSTAR(open, high, low, close[, penetration=?])\n\n    Evening Star (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Parameters:\n        penetration: 0.3\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_93CDLEVENINGSTAR = {"CDLEVENINGSTAR", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_93CDLEVENINGSTAR, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_92CDLEVENINGSTAR};
-static PyObject *__pyx_pw_5talib_7_ta_lib_93CDLEVENINGSTAR(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_71CDLABANDONEDBABY(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_70CDLABANDONEDBABY, "CDLABANDONEDBABY(ndarray open, ndarray high, ndarray low, ndarray close, double penetration=0.3)\n\nCDLABANDONEDBABY(open, high, low, close[, penetration=?])\n\nAbandoned Baby (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nParameters:\n    penetration: 0.3\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_71CDLABANDONEDBABY = {"CDLABANDONEDBABY", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_71CDLABANDONEDBABY, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_70CDLABANDONEDBABY};
+static PyObject *__pyx_pw_5talib_7_ta_lib_71CDLABANDONEDBABY(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_open = 0;
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
   double __pyx_v_penetration;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[5] = {0,0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("CDLEVENINGSTAR (wrapper)", 0);
+  __Pyx_RefNannySetupContext("CDLABANDONEDBABY (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,&__pyx_n_s_penetration,0};
-    PyObject* values[5] = {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  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,&__pyx_mstate_global->__pyx_n_u_penetration,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 990, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  5:
+        values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(4, 990, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 990, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 990, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 990, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 990, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLEVENINGSTAR", 0, 4, 5, 1); __PYX_ERR(2, 1344, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLEVENINGSTAR", 0, 4, 5, 2); __PYX_ERR(2, 1344, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLEVENINGSTAR", 0, 4, 5, 3); __PYX_ERR(2, 1344, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  4:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_penetration);
-          if (value) { values[4] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "CDLEVENINGSTAR") < 0)) __PYX_ERR(2, 1344, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLABANDONEDBABY", 0) < (0)) __PYX_ERR(4, 990, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLABANDONEDBABY", 0, 4, 5, i); __PYX_ERR(4, 990, __pyx_L3_error) }
       }
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
+      switch (__pyx_nargs) {
+        case  5:
+        values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(4, 990, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 990, __pyx_L3_error)
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 990, __pyx_L3_error)
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 990, __pyx_L3_error)
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 990, __pyx_L3_error)
         break;
         default: goto __pyx_L5_argtuple_error;
       }
@@ -12619,35 +13904,48 @@ static PyObject *__pyx_pw_5talib_7_ta_lib_93CDLEVENINGSTAR(PyObject *__pyx_self,
     __pyx_v_low = ((PyArrayObject *)values[2]);
     __pyx_v_close = ((PyArrayObject *)values[3]);
     if (values[4]) {
-      __pyx_v_penetration = __pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_penetration == (double)-1) && PyErr_Occurred())) __PYX_ERR(2, 1344, __pyx_L3_error)
+      __pyx_v_penetration = __Pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_penetration == (double)-1) && PyErr_Occurred())) __PYX_ERR(4, 992, __pyx_L3_error)
     } else {
-      __pyx_v_penetration = ((double)0.3);
+      __pyx_v_penetration = ((double)((double)0.3));
     }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("CDLEVENINGSTAR", 0, 4, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 1344, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("CDLABANDONEDBABY", 0, 4, 5, __pyx_nargs); __PYX_ERR(4, 990, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.CDLEVENINGSTAR", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.CDLABANDONEDBABY", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(2, 1344, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(2, 1344, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(2, 1344, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(2, 1344, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_92CDLEVENINGSTAR(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_penetration);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 992, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 992, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 992, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 992, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_70CDLABANDONEDBABY(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_penetration);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_92CDLEVENINGSTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_70CDLABANDONEDBABY(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -12661,55 +13959,58 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_92CDLEVENINGSTAR(CYTHON_UNUSED PyObjec
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
   npy_int __pyx_t_3;
-  __Pyx_RefNannySetupContext("CDLEVENINGSTAR", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("CDLABANDONEDBABY", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_open);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1363, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1011, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1364, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1012, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1365, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1013, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1366, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1014, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(2, 1367, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 1015, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
-  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_v_open->data), ((double *)__pyx_v_high->data), ((double *)__pyx_v_low->data), ((double *)__pyx_v_close->data)); if (unlikely(__pyx_t_3 == ((npy_int)-1))) __PYX_ERR(2, 1368, __pyx_L1_error)
+  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 1016, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_3;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLEVENINGSTAR_Lookback(__pyx_v_penetration));
+  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLABANDONEDBABY_Lookback(__pyx_v_penetration));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1371, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1019, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_CDLEVENINGSTAR(0, __pyx_v_endidx, (((double *)__pyx_v_open->data) + __pyx_v_begidx), (((double *)__pyx_v_high->data) + __pyx_v_begidx), (((double *)__pyx_v_low->data) + __pyx_v_begidx), (((double *)__pyx_v_close->data) + __pyx_v_begidx), __pyx_v_penetration, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_v_outinteger->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_CDLABANDONEDBABY(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), __pyx_v_penetration, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLEVENINGSTAR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1373, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLABANDONEDBABY, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1021, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outinteger));
+  __Pyx_INCREF((PyObject *)__pyx_v_outinteger);
   __pyx_r = ((PyObject *)__pyx_v_outinteger);
   goto __pyx_L0;
 
@@ -12717,7 +14018,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_92CDLEVENINGSTAR(CYTHON_UNUSED PyObjec
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.CDLEVENINGSTAR", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.CDLABANDONEDBABY", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_outinteger);
@@ -12732,99 +14033,129 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_92CDLEVENINGSTAR(CYTHON_UNUSED PyObjec
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_95CDLGAPSIDESIDEWHITE(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_94CDLGAPSIDESIDEWHITE[] = " CDLGAPSIDESIDEWHITE(open, high, low, close)\n\n    Up/Down-gap side-by-side white lines (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_95CDLGAPSIDESIDEWHITE = {"CDLGAPSIDESIDEWHITE", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_95CDLGAPSIDESIDEWHITE, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_94CDLGAPSIDESIDEWHITE};
-static PyObject *__pyx_pw_5talib_7_ta_lib_95CDLGAPSIDESIDEWHITE(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_73CDLADVANCEBLOCK(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_72CDLADVANCEBLOCK, "CDLADVANCEBLOCK(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLADVANCEBLOCK(open, high, low, close)\n\nAdvance Block (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_73CDLADVANCEBLOCK = {"CDLADVANCEBLOCK", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_73CDLADVANCEBLOCK, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_72CDLADVANCEBLOCK};
+static PyObject *__pyx_pw_5talib_7_ta_lib_73CDLADVANCEBLOCK(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_open = 0;
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("CDLGAPSIDESIDEWHITE (wrapper)", 0);
+  __Pyx_RefNannySetupContext("CDLADVANCEBLOCK (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 1024, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1024, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1024, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1024, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1024, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLGAPSIDESIDEWHITE", 1, 4, 4, 1); __PYX_ERR(2, 1378, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLGAPSIDESIDEWHITE", 1, 4, 4, 2); __PYX_ERR(2, 1378, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLGAPSIDESIDEWHITE", 1, 4, 4, 3); __PYX_ERR(2, 1378, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "CDLGAPSIDESIDEWHITE") < 0)) __PYX_ERR(2, 1378, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLADVANCEBLOCK", 0) < (0)) __PYX_ERR(4, 1024, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLADVANCEBLOCK", 1, 4, 4, i); __PYX_ERR(4, 1024, __pyx_L3_error) }
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
+    } else if (unlikely(__pyx_nargs != 4)) {
       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[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1024, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1024, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1024, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1024, __pyx_L3_error)
     }
     __pyx_v_open = ((PyArrayObject *)values[0]);
     __pyx_v_high = ((PyArrayObject *)values[1]);
     __pyx_v_low = ((PyArrayObject *)values[2]);
     __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("CDLGAPSIDESIDEWHITE", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 1378, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("CDLADVANCEBLOCK", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 1024, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.CDLGAPSIDESIDEWHITE", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.CDLADVANCEBLOCK", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(2, 1378, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(2, 1378, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(2, 1378, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(2, 1378, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_94CDLGAPSIDESIDEWHITE(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 1026, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 1026, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 1026, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 1026, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_72CDLADVANCEBLOCK(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_94CDLGAPSIDESIDEWHITE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_72CDLADVANCEBLOCK(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -12838,55 +14169,58 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_94CDLGAPSIDESIDEWHITE(CYTHON_UNUSED Py
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
   npy_int __pyx_t_3;
-  __Pyx_RefNannySetupContext("CDLGAPSIDESIDEWHITE", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("CDLADVANCEBLOCK", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_open);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1395, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1043, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1396, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1044, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1397, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1045, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1398, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1046, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(2, 1399, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 1047, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
-  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_v_open->data), ((double *)__pyx_v_high->data), ((double *)__pyx_v_low->data), ((double *)__pyx_v_close->data)); if (unlikely(__pyx_t_3 == ((npy_int)-1))) __PYX_ERR(2, 1400, __pyx_L1_error)
+  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 1048, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_3;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLGAPSIDESIDEWHITE_Lookback());
+  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLADVANCEBLOCK_Lookback());
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1403, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1051, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_CDLGAPSIDESIDEWHITE(0, __pyx_v_endidx, (((double *)__pyx_v_open->data) + __pyx_v_begidx), (((double *)__pyx_v_high->data) + __pyx_v_begidx), (((double *)__pyx_v_low->data) + __pyx_v_begidx), (((double *)__pyx_v_close->data) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_v_outinteger->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_CDLADVANCEBLOCK(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLGAPSIDESIDEWHITE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1405, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLADVANCEBLOCK, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1053, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outinteger));
+  __Pyx_INCREF((PyObject *)__pyx_v_outinteger);
   __pyx_r = ((PyObject *)__pyx_v_outinteger);
   goto __pyx_L0;
 
@@ -12894,7 +14228,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_94CDLGAPSIDESIDEWHITE(CYTHON_UNUSED Py
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.CDLGAPSIDESIDEWHITE", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.CDLADVANCEBLOCK", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_outinteger);
@@ -12909,99 +14243,129 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_94CDLGAPSIDESIDEWHITE(CYTHON_UNUSED Py
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_97CDLGRAVESTONEDOJI(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_96CDLGRAVESTONEDOJI[] = " CDLGRAVESTONEDOJI(open, high, low, close)\n\n    Gravestone Doji (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_97CDLGRAVESTONEDOJI = {"CDLGRAVESTONEDOJI", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_97CDLGRAVESTONEDOJI, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_96CDLGRAVESTONEDOJI};
-static PyObject *__pyx_pw_5talib_7_ta_lib_97CDLGRAVESTONEDOJI(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_75CDLBELTHOLD(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_74CDLBELTHOLD, "CDLBELTHOLD(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLBELTHOLD(open, high, low, close)\n\nBelt-hold (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_75CDLBELTHOLD = {"CDLBELTHOLD", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_75CDLBELTHOLD, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_74CDLBELTHOLD};
+static PyObject *__pyx_pw_5talib_7_ta_lib_75CDLBELTHOLD(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_open = 0;
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("CDLGRAVESTONEDOJI (wrapper)", 0);
+  __Pyx_RefNannySetupContext("CDLBELTHOLD (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 1056, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1056, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1056, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1056, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1056, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLGRAVESTONEDOJI", 1, 4, 4, 1); __PYX_ERR(2, 1410, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLGRAVESTONEDOJI", 1, 4, 4, 2); __PYX_ERR(2, 1410, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLGRAVESTONEDOJI", 1, 4, 4, 3); __PYX_ERR(2, 1410, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "CDLGRAVESTONEDOJI") < 0)) __PYX_ERR(2, 1410, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLBELTHOLD", 0) < (0)) __PYX_ERR(4, 1056, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLBELTHOLD", 1, 4, 4, i); __PYX_ERR(4, 1056, __pyx_L3_error) }
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
+    } else if (unlikely(__pyx_nargs != 4)) {
       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[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1056, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1056, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1056, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1056, __pyx_L3_error)
     }
     __pyx_v_open = ((PyArrayObject *)values[0]);
     __pyx_v_high = ((PyArrayObject *)values[1]);
     __pyx_v_low = ((PyArrayObject *)values[2]);
     __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("CDLGRAVESTONEDOJI", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 1410, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("CDLBELTHOLD", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 1056, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.CDLGRAVESTONEDOJI", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.CDLBELTHOLD", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(2, 1410, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(2, 1410, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(2, 1410, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(2, 1410, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_96CDLGRAVESTONEDOJI(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 1058, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 1058, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 1058, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 1058, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_74CDLBELTHOLD(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_96CDLGRAVESTONEDOJI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_74CDLBELTHOLD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -13015,55 +14379,58 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_96CDLGRAVESTONEDOJI(CYTHON_UNUSED PyOb
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
   npy_int __pyx_t_3;
-  __Pyx_RefNannySetupContext("CDLGRAVESTONEDOJI", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("CDLBELTHOLD", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_open);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1427, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1075, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1428, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1076, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1429, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1077, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1430, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1078, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(2, 1431, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 1079, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
-  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_v_open->data), ((double *)__pyx_v_high->data), ((double *)__pyx_v_low->data), ((double *)__pyx_v_close->data)); if (unlikely(__pyx_t_3 == ((npy_int)-1))) __PYX_ERR(2, 1432, __pyx_L1_error)
+  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 1080, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_3;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLGRAVESTONEDOJI_Lookback());
+  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLBELTHOLD_Lookback());
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1435, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1083, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_CDLGRAVESTONEDOJI(0, __pyx_v_endidx, (((double *)__pyx_v_open->data) + __pyx_v_begidx), (((double *)__pyx_v_high->data) + __pyx_v_begidx), (((double *)__pyx_v_low->data) + __pyx_v_begidx), (((double *)__pyx_v_close->data) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_v_outinteger->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_CDLBELTHOLD(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLGRAVESTONEDOJI, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1437, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLBELTHOLD, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1085, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outinteger));
+  __Pyx_INCREF((PyObject *)__pyx_v_outinteger);
   __pyx_r = ((PyObject *)__pyx_v_outinteger);
   goto __pyx_L0;
 
@@ -13071,7 +14438,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_96CDLGRAVESTONEDOJI(CYTHON_UNUSED PyOb
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.CDLGRAVESTONEDOJI", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.CDLBELTHOLD", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_outinteger);
@@ -13086,99 +14453,129 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_96CDLGRAVESTONEDOJI(CYTHON_UNUSED PyOb
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_99CDLHAMMER(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_98CDLHAMMER[] = " CDLHAMMER(open, high, low, close)\n\n    Hammer (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_99CDLHAMMER = {"CDLHAMMER", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_99CDLHAMMER, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_98CDLHAMMER};
-static PyObject *__pyx_pw_5talib_7_ta_lib_99CDLHAMMER(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_77CDLBREAKAWAY(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_76CDLBREAKAWAY, "CDLBREAKAWAY(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLBREAKAWAY(open, high, low, close)\n\nBreakaway (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_77CDLBREAKAWAY = {"CDLBREAKAWAY", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_77CDLBREAKAWAY, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_76CDLBREAKAWAY};
+static PyObject *__pyx_pw_5talib_7_ta_lib_77CDLBREAKAWAY(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_open = 0;
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("CDLHAMMER (wrapper)", 0);
+  __Pyx_RefNannySetupContext("CDLBREAKAWAY (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 1088, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1088, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1088, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1088, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1088, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLHAMMER", 1, 4, 4, 1); __PYX_ERR(2, 1442, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLHAMMER", 1, 4, 4, 2); __PYX_ERR(2, 1442, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLHAMMER", 1, 4, 4, 3); __PYX_ERR(2, 1442, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "CDLHAMMER") < 0)) __PYX_ERR(2, 1442, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLBREAKAWAY", 0) < (0)) __PYX_ERR(4, 1088, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLBREAKAWAY", 1, 4, 4, i); __PYX_ERR(4, 1088, __pyx_L3_error) }
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
+    } else if (unlikely(__pyx_nargs != 4)) {
       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[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1088, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1088, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1088, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1088, __pyx_L3_error)
     }
     __pyx_v_open = ((PyArrayObject *)values[0]);
     __pyx_v_high = ((PyArrayObject *)values[1]);
     __pyx_v_low = ((PyArrayObject *)values[2]);
     __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("CDLHAMMER", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 1442, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("CDLBREAKAWAY", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 1088, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.CDLHAMMER", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.CDLBREAKAWAY", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(2, 1442, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(2, 1442, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(2, 1442, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(2, 1442, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_98CDLHAMMER(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 1090, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 1090, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 1090, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 1090, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_76CDLBREAKAWAY(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_98CDLHAMMER(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_76CDLBREAKAWAY(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -13192,55 +14589,58 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_98CDLHAMMER(CYTHON_UNUSED PyObject *__
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
   npy_int __pyx_t_3;
-  __Pyx_RefNannySetupContext("CDLHAMMER", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("CDLBREAKAWAY", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_open);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1459, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1107, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1460, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1108, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1461, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1109, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1462, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1110, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(2, 1463, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 1111, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
-  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_v_open->data), ((double *)__pyx_v_high->data), ((double *)__pyx_v_low->data), ((double *)__pyx_v_close->data)); if (unlikely(__pyx_t_3 == ((npy_int)-1))) __PYX_ERR(2, 1464, __pyx_L1_error)
+  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 1112, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_3;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLHAMMER_Lookback());
+  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLBREAKAWAY_Lookback());
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1467, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1115, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_CDLHAMMER(0, __pyx_v_endidx, (((double *)__pyx_v_open->data) + __pyx_v_begidx), (((double *)__pyx_v_high->data) + __pyx_v_begidx), (((double *)__pyx_v_low->data) + __pyx_v_begidx), (((double *)__pyx_v_close->data) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_v_outinteger->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_CDLBREAKAWAY(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLHAMMER, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1469, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLBREAKAWAY, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1117, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outinteger));
+  __Pyx_INCREF((PyObject *)__pyx_v_outinteger);
   __pyx_r = ((PyObject *)__pyx_v_outinteger);
   goto __pyx_L0;
 
@@ -13248,7 +14648,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_98CDLHAMMER(CYTHON_UNUSED PyObject *__
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.CDLHAMMER", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.CDLBREAKAWAY", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_outinteger);
@@ -13263,99 +14663,129 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_98CDLHAMMER(CYTHON_UNUSED PyObject *__
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_101CDLHANGINGMAN(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_100CDLHANGINGMAN[] = " CDLHANGINGMAN(open, high, low, close)\n\n    Hanging Man (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_101CDLHANGINGMAN = {"CDLHANGINGMAN", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_101CDLHANGINGMAN, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_100CDLHANGINGMAN};
-static PyObject *__pyx_pw_5talib_7_ta_lib_101CDLHANGINGMAN(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_79CDLCLOSINGMARUBOZU(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_78CDLCLOSINGMARUBOZU, "CDLCLOSINGMARUBOZU(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLCLOSINGMARUBOZU(open, high, low, close)\n\nClosing Marubozu (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_79CDLCLOSINGMARUBOZU = {"CDLCLOSINGMARUBOZU", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_79CDLCLOSINGMARUBOZU, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_78CDLCLOSINGMARUBOZU};
+static PyObject *__pyx_pw_5talib_7_ta_lib_79CDLCLOSINGMARUBOZU(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_open = 0;
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("CDLHANGINGMAN (wrapper)", 0);
+  __Pyx_RefNannySetupContext("CDLCLOSINGMARUBOZU (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 1120, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1120, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1120, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1120, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1120, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLHANGINGMAN", 1, 4, 4, 1); __PYX_ERR(2, 1474, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLHANGINGMAN", 1, 4, 4, 2); __PYX_ERR(2, 1474, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLHANGINGMAN", 1, 4, 4, 3); __PYX_ERR(2, 1474, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "CDLHANGINGMAN") < 0)) __PYX_ERR(2, 1474, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLCLOSINGMARUBOZU", 0) < (0)) __PYX_ERR(4, 1120, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLCLOSINGMARUBOZU", 1, 4, 4, i); __PYX_ERR(4, 1120, __pyx_L3_error) }
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
+    } else if (unlikely(__pyx_nargs != 4)) {
       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[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1120, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1120, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1120, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1120, __pyx_L3_error)
     }
     __pyx_v_open = ((PyArrayObject *)values[0]);
     __pyx_v_high = ((PyArrayObject *)values[1]);
     __pyx_v_low = ((PyArrayObject *)values[2]);
     __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("CDLHANGINGMAN", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 1474, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("CDLCLOSINGMARUBOZU", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 1120, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.CDLHANGINGMAN", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.CDLCLOSINGMARUBOZU", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(2, 1474, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(2, 1474, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(2, 1474, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(2, 1474, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_100CDLHANGINGMAN(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 1122, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 1122, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 1122, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 1122, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_78CDLCLOSINGMARUBOZU(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_100CDLHANGINGMAN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_78CDLCLOSINGMARUBOZU(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -13369,55 +14799,58 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_100CDLHANGINGMAN(CYTHON_UNUSED PyObjec
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
   npy_int __pyx_t_3;
-  __Pyx_RefNannySetupContext("CDLHANGINGMAN", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("CDLCLOSINGMARUBOZU", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_open);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1491, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1139, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1492, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1140, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1493, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1141, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1494, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1142, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(2, 1495, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 1143, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
-  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_v_open->data), ((double *)__pyx_v_high->data), ((double *)__pyx_v_low->data), ((double *)__pyx_v_close->data)); if (unlikely(__pyx_t_3 == ((npy_int)-1))) __PYX_ERR(2, 1496, __pyx_L1_error)
+  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 1144, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_3;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLHANGINGMAN_Lookback());
+  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLCLOSINGMARUBOZU_Lookback());
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1499, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1147, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_CDLHANGINGMAN(0, __pyx_v_endidx, (((double *)__pyx_v_open->data) + __pyx_v_begidx), (((double *)__pyx_v_high->data) + __pyx_v_begidx), (((double *)__pyx_v_low->data) + __pyx_v_begidx), (((double *)__pyx_v_close->data) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_v_outinteger->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_CDLCLOSINGMARUBOZU(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLHANGINGMAN, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1501, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLCLOSINGMARUBOZU, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1149, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outinteger));
+  __Pyx_INCREF((PyObject *)__pyx_v_outinteger);
   __pyx_r = ((PyObject *)__pyx_v_outinteger);
   goto __pyx_L0;
 
@@ -13425,7 +14858,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_100CDLHANGINGMAN(CYTHON_UNUSED PyObjec
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.CDLHANGINGMAN", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.CDLCLOSINGMARUBOZU", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_outinteger);
@@ -13440,99 +14873,129 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_100CDLHANGINGMAN(CYTHON_UNUSED PyObjec
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_103CDLHARAMI(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_102CDLHARAMI[] = " CDLHARAMI(open, high, low, close)\n\n    Harami Pattern (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_103CDLHARAMI = {"CDLHARAMI", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_103CDLHARAMI, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_102CDLHARAMI};
-static PyObject *__pyx_pw_5talib_7_ta_lib_103CDLHARAMI(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_81CDLCONCEALBABYSWALL(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_80CDLCONCEALBABYSWALL, "CDLCONCEALBABYSWALL(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLCONCEALBABYSWALL(open, high, low, close)\n\nConcealing Baby Swallow (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_81CDLCONCEALBABYSWALL = {"CDLCONCEALBABYSWALL", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_81CDLCONCEALBABYSWALL, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_80CDLCONCEALBABYSWALL};
+static PyObject *__pyx_pw_5talib_7_ta_lib_81CDLCONCEALBABYSWALL(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_open = 0;
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("CDLHARAMI (wrapper)", 0);
+  __Pyx_RefNannySetupContext("CDLCONCEALBABYSWALL (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 1152, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1152, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1152, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1152, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1152, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLHARAMI", 1, 4, 4, 1); __PYX_ERR(2, 1506, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLHARAMI", 1, 4, 4, 2); __PYX_ERR(2, 1506, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLHARAMI", 1, 4, 4, 3); __PYX_ERR(2, 1506, __pyx_L3_error)
-        }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLCONCEALBABYSWALL", 0) < (0)) __PYX_ERR(4, 1152, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLCONCEALBABYSWALL", 1, 4, 4, i); __PYX_ERR(4, 1152, __pyx_L3_error) }
       }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "CDLHARAMI") < 0)) __PYX_ERR(2, 1506, __pyx_L3_error)
-      }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
+    } else if (unlikely(__pyx_nargs != 4)) {
       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[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1152, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1152, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1152, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1152, __pyx_L3_error)
     }
     __pyx_v_open = ((PyArrayObject *)values[0]);
     __pyx_v_high = ((PyArrayObject *)values[1]);
     __pyx_v_low = ((PyArrayObject *)values[2]);
     __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("CDLHARAMI", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 1506, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("CDLCONCEALBABYSWALL", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 1152, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.CDLHARAMI", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.CDLCONCEALBABYSWALL", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(2, 1506, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(2, 1506, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(2, 1506, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(2, 1506, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_102CDLHARAMI(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 1154, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 1154, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 1154, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 1154, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_80CDLCONCEALBABYSWALL(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_102CDLHARAMI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_80CDLCONCEALBABYSWALL(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -13546,55 +15009,58 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_102CDLHARAMI(CYTHON_UNUSED PyObject *_
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
   npy_int __pyx_t_3;
-  __Pyx_RefNannySetupContext("CDLHARAMI", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("CDLCONCEALBABYSWALL", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_open);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1523, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1171, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1524, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1172, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1525, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1173, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1526, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1174, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(2, 1527, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 1175, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
-  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_v_open->data), ((double *)__pyx_v_high->data), ((double *)__pyx_v_low->data), ((double *)__pyx_v_close->data)); if (unlikely(__pyx_t_3 == ((npy_int)-1))) __PYX_ERR(2, 1528, __pyx_L1_error)
+  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 1176, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_3;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLHARAMI_Lookback());
+  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLCONCEALBABYSWALL_Lookback());
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1531, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1179, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_CDLHARAMI(0, __pyx_v_endidx, (((double *)__pyx_v_open->data) + __pyx_v_begidx), (((double *)__pyx_v_high->data) + __pyx_v_begidx), (((double *)__pyx_v_low->data) + __pyx_v_begidx), (((double *)__pyx_v_close->data) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_v_outinteger->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_CDLCONCEALBABYSWALL(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLHARAMI, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1533, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLCONCEALBABYSWALL, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1181, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outinteger));
+  __Pyx_INCREF((PyObject *)__pyx_v_outinteger);
   __pyx_r = ((PyObject *)__pyx_v_outinteger);
   goto __pyx_L0;
 
@@ -13602,7 +15068,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_102CDLHARAMI(CYTHON_UNUSED PyObject *_
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.CDLHARAMI", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.CDLCONCEALBABYSWALL", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_outinteger);
@@ -13617,99 +15083,129 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_102CDLHARAMI(CYTHON_UNUSED PyObject *_
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_105CDLHARAMICROSS(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_104CDLHARAMICROSS[] = " CDLHARAMICROSS(open, high, low, close)\n\n    Harami Cross Pattern (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_105CDLHARAMICROSS = {"CDLHARAMICROSS", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_105CDLHARAMICROSS, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_104CDLHARAMICROSS};
-static PyObject *__pyx_pw_5talib_7_ta_lib_105CDLHARAMICROSS(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_83CDLCOUNTERATTACK(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_82CDLCOUNTERATTACK, "CDLCOUNTERATTACK(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLCOUNTERATTACK(open, high, low, close)\n\nCounterattack (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_83CDLCOUNTERATTACK = {"CDLCOUNTERATTACK", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_83CDLCOUNTERATTACK, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_82CDLCOUNTERATTACK};
+static PyObject *__pyx_pw_5talib_7_ta_lib_83CDLCOUNTERATTACK(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_open = 0;
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("CDLHARAMICROSS (wrapper)", 0);
+  __Pyx_RefNannySetupContext("CDLCOUNTERATTACK (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 1184, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1184, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1184, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1184, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1184, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLHARAMICROSS", 1, 4, 4, 1); __PYX_ERR(2, 1538, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLHARAMICROSS", 1, 4, 4, 2); __PYX_ERR(2, 1538, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLHARAMICROSS", 1, 4, 4, 3); __PYX_ERR(2, 1538, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "CDLHARAMICROSS") < 0)) __PYX_ERR(2, 1538, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLCOUNTERATTACK", 0) < (0)) __PYX_ERR(4, 1184, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLCOUNTERATTACK", 1, 4, 4, i); __PYX_ERR(4, 1184, __pyx_L3_error) }
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
+    } else if (unlikely(__pyx_nargs != 4)) {
       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[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1184, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1184, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1184, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1184, __pyx_L3_error)
     }
     __pyx_v_open = ((PyArrayObject *)values[0]);
     __pyx_v_high = ((PyArrayObject *)values[1]);
     __pyx_v_low = ((PyArrayObject *)values[2]);
     __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("CDLHARAMICROSS", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 1538, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("CDLCOUNTERATTACK", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 1184, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.CDLHARAMICROSS", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.CDLCOUNTERATTACK", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(2, 1538, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(2, 1538, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(2, 1538, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(2, 1538, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_104CDLHARAMICROSS(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 1186, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 1186, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 1186, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 1186, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_82CDLCOUNTERATTACK(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_104CDLHARAMICROSS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_82CDLCOUNTERATTACK(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -13723,55 +15219,58 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_104CDLHARAMICROSS(CYTHON_UNUSED PyObje
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
   npy_int __pyx_t_3;
-  __Pyx_RefNannySetupContext("CDLHARAMICROSS", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("CDLCOUNTERATTACK", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_open);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1555, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1203, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1556, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1204, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1557, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1205, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1558, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1206, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(2, 1559, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 1207, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
-  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_v_open->data), ((double *)__pyx_v_high->data), ((double *)__pyx_v_low->data), ((double *)__pyx_v_close->data)); if (unlikely(__pyx_t_3 == ((npy_int)-1))) __PYX_ERR(2, 1560, __pyx_L1_error)
+  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 1208, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_3;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLHARAMICROSS_Lookback());
+  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLCOUNTERATTACK_Lookback());
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1563, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1211, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_CDLHARAMICROSS(0, __pyx_v_endidx, (((double *)__pyx_v_open->data) + __pyx_v_begidx), (((double *)__pyx_v_high->data) + __pyx_v_begidx), (((double *)__pyx_v_low->data) + __pyx_v_begidx), (((double *)__pyx_v_close->data) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_v_outinteger->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_CDLCOUNTERATTACK(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLHARAMICROSS, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1565, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLCOUNTERATTACK, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1213, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outinteger));
+  __Pyx_INCREF((PyObject *)__pyx_v_outinteger);
   __pyx_r = ((PyObject *)__pyx_v_outinteger);
   goto __pyx_L0;
 
@@ -13779,7 +15278,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_104CDLHARAMICROSS(CYTHON_UNUSED PyObje
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.CDLHARAMICROSS", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.CDLCOUNTERATTACK", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_outinteger);
@@ -13794,99 +15293,146 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_104CDLHARAMICROSS(CYTHON_UNUSED PyObje
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_107CDLHIGHWAVE(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_106CDLHIGHWAVE[] = " CDLHIGHWAVE(open, high, low, close)\n\n    High-Wave Candle (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_107CDLHIGHWAVE = {"CDLHIGHWAVE", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_107CDLHIGHWAVE, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_106CDLHIGHWAVE};
-static PyObject *__pyx_pw_5talib_7_ta_lib_107CDLHIGHWAVE(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_85CDLDARKCLOUDCOVER(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_84CDLDARKCLOUDCOVER, "CDLDARKCLOUDCOVER(ndarray open, ndarray high, ndarray low, ndarray close, double penetration=0.5)\n\nCDLDARKCLOUDCOVER(open, high, low, close[, penetration=?])\n\nDark Cloud Cover (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nParameters:\n    penetration: 0.5\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_85CDLDARKCLOUDCOVER = {"CDLDARKCLOUDCOVER", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_85CDLDARKCLOUDCOVER, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_84CDLDARKCLOUDCOVER};
+static PyObject *__pyx_pw_5talib_7_ta_lib_85CDLDARKCLOUDCOVER(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_open = 0;
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
+  double __pyx_v_penetration;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[5] = {0,0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("CDLHIGHWAVE (wrapper)", 0);
+  __Pyx_RefNannySetupContext("CDLDARKCLOUDCOVER (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,&__pyx_mstate_global->__pyx_n_u_penetration,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 1216, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  5:
+        values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(4, 1216, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1216, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1216, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  0: break;
-        default: goto __pyx_L5_argtuple_error;
-      }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1216, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLHIGHWAVE", 1, 4, 4, 1); __PYX_ERR(2, 1570, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLHIGHWAVE", 1, 4, 4, 2); __PYX_ERR(2, 1570, __pyx_L3_error)
-        }
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1216, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLHIGHWAVE", 1, 4, 4, 3); __PYX_ERR(2, 1570, __pyx_L3_error)
-        }
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
       }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "CDLHIGHWAVE") < 0)) __PYX_ERR(2, 1570, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLDARKCLOUDCOVER", 0) < (0)) __PYX_ERR(4, 1216, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLDARKCLOUDCOVER", 0, 4, 5, i); __PYX_ERR(4, 1216, __pyx_L3_error) }
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
-      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);
+      switch (__pyx_nargs) {
+        case  5:
+        values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(4, 1216, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1216, __pyx_L3_error)
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1216, __pyx_L3_error)
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1216, __pyx_L3_error)
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1216, __pyx_L3_error)
+        break;
+        default: goto __pyx_L5_argtuple_error;
+      }
     }
     __pyx_v_open = ((PyArrayObject *)values[0]);
     __pyx_v_high = ((PyArrayObject *)values[1]);
     __pyx_v_low = ((PyArrayObject *)values[2]);
     __pyx_v_close = ((PyArrayObject *)values[3]);
+    if (values[4]) {
+      __pyx_v_penetration = __Pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_penetration == (double)-1) && PyErr_Occurred())) __PYX_ERR(4, 1218, __pyx_L3_error)
+    } else {
+      __pyx_v_penetration = ((double)((double)0.5));
+    }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("CDLHIGHWAVE", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 1570, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("CDLDARKCLOUDCOVER", 0, 4, 5, __pyx_nargs); __PYX_ERR(4, 1216, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.CDLHIGHWAVE", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.CDLDARKCLOUDCOVER", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(2, 1570, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(2, 1570, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(2, 1570, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(2, 1570, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_106CDLHIGHWAVE(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 1218, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 1218, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 1218, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 1218, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_84CDLDARKCLOUDCOVER(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_penetration);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_106CDLHIGHWAVE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_84CDLDARKCLOUDCOVER(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -13900,55 +15446,58 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_106CDLHIGHWAVE(CYTHON_UNUSED PyObject
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
   npy_int __pyx_t_3;
-  __Pyx_RefNannySetupContext("CDLHIGHWAVE", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("CDLDARKCLOUDCOVER", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_open);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1587, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1237, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1588, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1238, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1589, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1239, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1590, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1240, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(2, 1591, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 1241, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
-  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_v_open->data), ((double *)__pyx_v_high->data), ((double *)__pyx_v_low->data), ((double *)__pyx_v_close->data)); if (unlikely(__pyx_t_3 == ((npy_int)-1))) __PYX_ERR(2, 1592, __pyx_L1_error)
+  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 1242, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_3;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLHIGHWAVE_Lookback());
+  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLDARKCLOUDCOVER_Lookback(__pyx_v_penetration));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1595, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1245, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_CDLHIGHWAVE(0, __pyx_v_endidx, (((double *)__pyx_v_open->data) + __pyx_v_begidx), (((double *)__pyx_v_high->data) + __pyx_v_begidx), (((double *)__pyx_v_low->data) + __pyx_v_begidx), (((double *)__pyx_v_close->data) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_v_outinteger->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_CDLDARKCLOUDCOVER(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), __pyx_v_penetration, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLHIGHWAVE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1597, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLDARKCLOUDCOVER, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1247, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outinteger));
+  __Pyx_INCREF((PyObject *)__pyx_v_outinteger);
   __pyx_r = ((PyObject *)__pyx_v_outinteger);
   goto __pyx_L0;
 
@@ -13956,7 +15505,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_106CDLHIGHWAVE(CYTHON_UNUSED PyObject
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.CDLHIGHWAVE", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.CDLDARKCLOUDCOVER", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_outinteger);
@@ -13971,99 +15520,129 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_106CDLHIGHWAVE(CYTHON_UNUSED PyObject
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_109CDLHIKKAKE(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_108CDLHIKKAKE[] = " CDLHIKKAKE(open, high, low, close)\n\n    Hikkake Pattern (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_109CDLHIKKAKE = {"CDLHIKKAKE", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_109CDLHIKKAKE, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_108CDLHIKKAKE};
-static PyObject *__pyx_pw_5talib_7_ta_lib_109CDLHIKKAKE(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_87CDLDOJI(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_86CDLDOJI, "CDLDOJI(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLDOJI(open, high, low, close)\n\nDoji (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_87CDLDOJI = {"CDLDOJI", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_87CDLDOJI, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_86CDLDOJI};
+static PyObject *__pyx_pw_5talib_7_ta_lib_87CDLDOJI(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_open = 0;
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("CDLHIKKAKE (wrapper)", 0);
+  __Pyx_RefNannySetupContext("CDLDOJI (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 1250, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1250, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1250, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1250, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1250, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLHIKKAKE", 1, 4, 4, 1); __PYX_ERR(2, 1602, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLHIKKAKE", 1, 4, 4, 2); __PYX_ERR(2, 1602, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLHIKKAKE", 1, 4, 4, 3); __PYX_ERR(2, 1602, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "CDLHIKKAKE") < 0)) __PYX_ERR(2, 1602, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLDOJI", 0) < (0)) __PYX_ERR(4, 1250, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLDOJI", 1, 4, 4, i); __PYX_ERR(4, 1250, __pyx_L3_error) }
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
+    } else if (unlikely(__pyx_nargs != 4)) {
       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[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1250, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1250, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1250, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1250, __pyx_L3_error)
     }
     __pyx_v_open = ((PyArrayObject *)values[0]);
     __pyx_v_high = ((PyArrayObject *)values[1]);
     __pyx_v_low = ((PyArrayObject *)values[2]);
     __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("CDLHIKKAKE", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 1602, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("CDLDOJI", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 1250, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.CDLHIKKAKE", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.CDLDOJI", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(2, 1602, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(2, 1602, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(2, 1602, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(2, 1602, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_108CDLHIKKAKE(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 1252, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 1252, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 1252, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 1252, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_86CDLDOJI(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_108CDLHIKKAKE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_86CDLDOJI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -14077,55 +15656,58 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_108CDLHIKKAKE(CYTHON_UNUSED PyObject *
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
   npy_int __pyx_t_3;
-  __Pyx_RefNannySetupContext("CDLHIKKAKE", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("CDLDOJI", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_open);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1619, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1269, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1620, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1270, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1621, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1271, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1622, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1272, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(2, 1623, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 1273, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
-  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_v_open->data), ((double *)__pyx_v_high->data), ((double *)__pyx_v_low->data), ((double *)__pyx_v_close->data)); if (unlikely(__pyx_t_3 == ((npy_int)-1))) __PYX_ERR(2, 1624, __pyx_L1_error)
+  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 1274, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_3;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLHIKKAKE_Lookback());
+  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLDOJI_Lookback());
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1627, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1277, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_CDLHIKKAKE(0, __pyx_v_endidx, (((double *)__pyx_v_open->data) + __pyx_v_begidx), (((double *)__pyx_v_high->data) + __pyx_v_begidx), (((double *)__pyx_v_low->data) + __pyx_v_begidx), (((double *)__pyx_v_close->data) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_v_outinteger->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_CDLDOJI(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLHIKKAKE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1629, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLDOJI, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1279, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outinteger));
+  __Pyx_INCREF((PyObject *)__pyx_v_outinteger);
   __pyx_r = ((PyObject *)__pyx_v_outinteger);
   goto __pyx_L0;
 
@@ -14133,7 +15715,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_108CDLHIKKAKE(CYTHON_UNUSED PyObject *
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.CDLHIKKAKE", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.CDLDOJI", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_outinteger);
@@ -14148,99 +15730,129 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_108CDLHIKKAKE(CYTHON_UNUSED PyObject *
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_111CDLHIKKAKEMOD(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_110CDLHIKKAKEMOD[] = " CDLHIKKAKEMOD(open, high, low, close)\n\n    Modified Hikkake Pattern (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_111CDLHIKKAKEMOD = {"CDLHIKKAKEMOD", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_111CDLHIKKAKEMOD, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_110CDLHIKKAKEMOD};
-static PyObject *__pyx_pw_5talib_7_ta_lib_111CDLHIKKAKEMOD(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_89CDLDOJISTAR(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_88CDLDOJISTAR, "CDLDOJISTAR(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLDOJISTAR(open, high, low, close)\n\nDoji Star (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_89CDLDOJISTAR = {"CDLDOJISTAR", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_89CDLDOJISTAR, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_88CDLDOJISTAR};
+static PyObject *__pyx_pw_5talib_7_ta_lib_89CDLDOJISTAR(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_open = 0;
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("CDLHIKKAKEMOD (wrapper)", 0);
+  __Pyx_RefNannySetupContext("CDLDOJISTAR (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 1282, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1282, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1282, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1282, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1282, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLHIKKAKEMOD", 1, 4, 4, 1); __PYX_ERR(2, 1634, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLHIKKAKEMOD", 1, 4, 4, 2); __PYX_ERR(2, 1634, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLHIKKAKEMOD", 1, 4, 4, 3); __PYX_ERR(2, 1634, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "CDLHIKKAKEMOD") < 0)) __PYX_ERR(2, 1634, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLDOJISTAR", 0) < (0)) __PYX_ERR(4, 1282, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLDOJISTAR", 1, 4, 4, i); __PYX_ERR(4, 1282, __pyx_L3_error) }
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
+    } else if (unlikely(__pyx_nargs != 4)) {
       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[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1282, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1282, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1282, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1282, __pyx_L3_error)
     }
     __pyx_v_open = ((PyArrayObject *)values[0]);
     __pyx_v_high = ((PyArrayObject *)values[1]);
     __pyx_v_low = ((PyArrayObject *)values[2]);
     __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("CDLHIKKAKEMOD", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 1634, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("CDLDOJISTAR", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 1282, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.CDLHIKKAKEMOD", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.CDLDOJISTAR", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(2, 1634, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(2, 1634, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(2, 1634, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(2, 1634, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_110CDLHIKKAKEMOD(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 1284, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 1284, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 1284, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 1284, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_88CDLDOJISTAR(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_110CDLHIKKAKEMOD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_88CDLDOJISTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -14254,55 +15866,58 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_110CDLHIKKAKEMOD(CYTHON_UNUSED PyObjec
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
   npy_int __pyx_t_3;
-  __Pyx_RefNannySetupContext("CDLHIKKAKEMOD", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("CDLDOJISTAR", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_open);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1651, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1301, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1652, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1302, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1653, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1303, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1654, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1304, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(2, 1655, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 1305, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
-  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_v_open->data), ((double *)__pyx_v_high->data), ((double *)__pyx_v_low->data), ((double *)__pyx_v_close->data)); if (unlikely(__pyx_t_3 == ((npy_int)-1))) __PYX_ERR(2, 1656, __pyx_L1_error)
+  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 1306, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_3;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLHIKKAKEMOD_Lookback());
+  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLDOJISTAR_Lookback());
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1659, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1309, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_CDLHIKKAKEMOD(0, __pyx_v_endidx, (((double *)__pyx_v_open->data) + __pyx_v_begidx), (((double *)__pyx_v_high->data) + __pyx_v_begidx), (((double *)__pyx_v_low->data) + __pyx_v_begidx), (((double *)__pyx_v_close->data) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_v_outinteger->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_CDLDOJISTAR(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLHIKKAKEMOD, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1661, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLDOJISTAR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1311, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outinteger));
+  __Pyx_INCREF((PyObject *)__pyx_v_outinteger);
   __pyx_r = ((PyObject *)__pyx_v_outinteger);
   goto __pyx_L0;
 
@@ -14310,7 +15925,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_110CDLHIKKAKEMOD(CYTHON_UNUSED PyObjec
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.CDLHIKKAKEMOD", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.CDLDOJISTAR", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_outinteger);
@@ -14325,99 +15940,129 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_110CDLHIKKAKEMOD(CYTHON_UNUSED PyObjec
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_113CDLHOMINGPIGEON(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_112CDLHOMINGPIGEON[] = " CDLHOMINGPIGEON(open, high, low, close)\n\n    Homing Pigeon (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_113CDLHOMINGPIGEON = {"CDLHOMINGPIGEON", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_113CDLHOMINGPIGEON, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_112CDLHOMINGPIGEON};
-static PyObject *__pyx_pw_5talib_7_ta_lib_113CDLHOMINGPIGEON(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_91CDLDRAGONFLYDOJI(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_90CDLDRAGONFLYDOJI, "CDLDRAGONFLYDOJI(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLDRAGONFLYDOJI(open, high, low, close)\n\nDragonfly Doji (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_91CDLDRAGONFLYDOJI = {"CDLDRAGONFLYDOJI", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_91CDLDRAGONFLYDOJI, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_90CDLDRAGONFLYDOJI};
+static PyObject *__pyx_pw_5talib_7_ta_lib_91CDLDRAGONFLYDOJI(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_open = 0;
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("CDLHOMINGPIGEON (wrapper)", 0);
+  __Pyx_RefNannySetupContext("CDLDRAGONFLYDOJI (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 1314, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1314, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1314, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1314, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1314, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLHOMINGPIGEON", 1, 4, 4, 1); __PYX_ERR(2, 1666, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLHOMINGPIGEON", 1, 4, 4, 2); __PYX_ERR(2, 1666, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLHOMINGPIGEON", 1, 4, 4, 3); __PYX_ERR(2, 1666, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "CDLHOMINGPIGEON") < 0)) __PYX_ERR(2, 1666, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLDRAGONFLYDOJI", 0) < (0)) __PYX_ERR(4, 1314, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLDRAGONFLYDOJI", 1, 4, 4, i); __PYX_ERR(4, 1314, __pyx_L3_error) }
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
+    } else if (unlikely(__pyx_nargs != 4)) {
       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[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1314, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1314, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1314, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1314, __pyx_L3_error)
     }
     __pyx_v_open = ((PyArrayObject *)values[0]);
     __pyx_v_high = ((PyArrayObject *)values[1]);
     __pyx_v_low = ((PyArrayObject *)values[2]);
     __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("CDLHOMINGPIGEON", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 1666, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("CDLDRAGONFLYDOJI", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 1314, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.CDLHOMINGPIGEON", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.CDLDRAGONFLYDOJI", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(2, 1666, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(2, 1666, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(2, 1666, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(2, 1666, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_112CDLHOMINGPIGEON(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 1316, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 1316, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 1316, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 1316, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_90CDLDRAGONFLYDOJI(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_112CDLHOMINGPIGEON(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_90CDLDRAGONFLYDOJI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -14431,55 +16076,58 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_112CDLHOMINGPIGEON(CYTHON_UNUSED PyObj
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
   npy_int __pyx_t_3;
-  __Pyx_RefNannySetupContext("CDLHOMINGPIGEON", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("CDLDRAGONFLYDOJI", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_open);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1683, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1333, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1684, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1334, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1685, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1335, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1686, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1336, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(2, 1687, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 1337, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
-  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_v_open->data), ((double *)__pyx_v_high->data), ((double *)__pyx_v_low->data), ((double *)__pyx_v_close->data)); if (unlikely(__pyx_t_3 == ((npy_int)-1))) __PYX_ERR(2, 1688, __pyx_L1_error)
+  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 1338, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_3;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLHOMINGPIGEON_Lookback());
+  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLDRAGONFLYDOJI_Lookback());
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1691, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1341, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_CDLHOMINGPIGEON(0, __pyx_v_endidx, (((double *)__pyx_v_open->data) + __pyx_v_begidx), (((double *)__pyx_v_high->data) + __pyx_v_begidx), (((double *)__pyx_v_low->data) + __pyx_v_begidx), (((double *)__pyx_v_close->data) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_v_outinteger->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_CDLDRAGONFLYDOJI(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLHOMINGPIGEON, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1693, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLDRAGONFLYDOJI, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1343, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outinteger));
+  __Pyx_INCREF((PyObject *)__pyx_v_outinteger);
   __pyx_r = ((PyObject *)__pyx_v_outinteger);
   goto __pyx_L0;
 
@@ -14487,7 +16135,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_112CDLHOMINGPIGEON(CYTHON_UNUSED PyObj
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.CDLHOMINGPIGEON", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.CDLDRAGONFLYDOJI", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_outinteger);
@@ -14502,99 +16150,129 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_112CDLHOMINGPIGEON(CYTHON_UNUSED PyObj
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_115CDLIDENTICAL3CROWS(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_114CDLIDENTICAL3CROWS[] = " CDLIDENTICAL3CROWS(open, high, low, close)\n\n    Identical Three Crows (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_115CDLIDENTICAL3CROWS = {"CDLIDENTICAL3CROWS", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_115CDLIDENTICAL3CROWS, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_114CDLIDENTICAL3CROWS};
-static PyObject *__pyx_pw_5talib_7_ta_lib_115CDLIDENTICAL3CROWS(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_93CDLENGULFING(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_92CDLENGULFING, "CDLENGULFING(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLENGULFING(open, high, low, close)\n\nEngulfing Pattern (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_93CDLENGULFING = {"CDLENGULFING", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_93CDLENGULFING, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_92CDLENGULFING};
+static PyObject *__pyx_pw_5talib_7_ta_lib_93CDLENGULFING(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_open = 0;
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("CDLIDENTICAL3CROWS (wrapper)", 0);
+  __Pyx_RefNannySetupContext("CDLENGULFING (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 1346, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1346, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1346, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1346, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1346, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLIDENTICAL3CROWS", 1, 4, 4, 1); __PYX_ERR(2, 1698, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLIDENTICAL3CROWS", 1, 4, 4, 2); __PYX_ERR(2, 1698, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLIDENTICAL3CROWS", 1, 4, 4, 3); __PYX_ERR(2, 1698, __pyx_L3_error)
-        }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLENGULFING", 0) < (0)) __PYX_ERR(4, 1346, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLENGULFING", 1, 4, 4, i); __PYX_ERR(4, 1346, __pyx_L3_error) }
       }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "CDLIDENTICAL3CROWS") < 0)) __PYX_ERR(2, 1698, __pyx_L3_error)
-      }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
+    } else if (unlikely(__pyx_nargs != 4)) {
       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[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1346, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1346, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1346, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1346, __pyx_L3_error)
     }
     __pyx_v_open = ((PyArrayObject *)values[0]);
     __pyx_v_high = ((PyArrayObject *)values[1]);
     __pyx_v_low = ((PyArrayObject *)values[2]);
     __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("CDLIDENTICAL3CROWS", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 1698, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("CDLENGULFING", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 1346, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.CDLIDENTICAL3CROWS", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.CDLENGULFING", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(2, 1698, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(2, 1698, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(2, 1698, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(2, 1698, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_114CDLIDENTICAL3CROWS(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 1348, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 1348, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 1348, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 1348, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_92CDLENGULFING(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_114CDLIDENTICAL3CROWS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_92CDLENGULFING(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -14608,55 +16286,58 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_114CDLIDENTICAL3CROWS(CYTHON_UNUSED Py
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
   npy_int __pyx_t_3;
-  __Pyx_RefNannySetupContext("CDLIDENTICAL3CROWS", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("CDLENGULFING", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_open);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1715, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1365, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1716, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1366, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1717, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1367, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1718, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1368, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(2, 1719, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 1369, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
-  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_v_open->data), ((double *)__pyx_v_high->data), ((double *)__pyx_v_low->data), ((double *)__pyx_v_close->data)); if (unlikely(__pyx_t_3 == ((npy_int)-1))) __PYX_ERR(2, 1720, __pyx_L1_error)
+  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 1370, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_3;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLIDENTICAL3CROWS_Lookback());
+  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLENGULFING_Lookback());
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1723, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1373, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_CDLIDENTICAL3CROWS(0, __pyx_v_endidx, (((double *)__pyx_v_open->data) + __pyx_v_begidx), (((double *)__pyx_v_high->data) + __pyx_v_begidx), (((double *)__pyx_v_low->data) + __pyx_v_begidx), (((double *)__pyx_v_close->data) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_v_outinteger->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_CDLENGULFING(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLIDENTICAL3CROWS, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1725, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLENGULFING, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1375, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outinteger));
+  __Pyx_INCREF((PyObject *)__pyx_v_outinteger);
   __pyx_r = ((PyObject *)__pyx_v_outinteger);
   goto __pyx_L0;
 
@@ -14664,7 +16345,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_114CDLIDENTICAL3CROWS(CYTHON_UNUSED Py
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.CDLIDENTICAL3CROWS", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.CDLENGULFING", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_outinteger);
@@ -14679,99 +16360,146 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_114CDLIDENTICAL3CROWS(CYTHON_UNUSED Py
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_117CDLINNECK(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_116CDLINNECK[] = " CDLINNECK(open, high, low, close)\n\n    In-Neck Pattern (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_117CDLINNECK = {"CDLINNECK", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_117CDLINNECK, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_116CDLINNECK};
-static PyObject *__pyx_pw_5talib_7_ta_lib_117CDLINNECK(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_95CDLEVENINGDOJISTAR(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_94CDLEVENINGDOJISTAR, "CDLEVENINGDOJISTAR(ndarray open, ndarray high, ndarray low, ndarray close, double penetration=0.3)\n\nCDLEVENINGDOJISTAR(open, high, low, close[, penetration=?])\n\nEvening Doji Star (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nParameters:\n    penetration: 0.3\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_95CDLEVENINGDOJISTAR = {"CDLEVENINGDOJISTAR", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_95CDLEVENINGDOJISTAR, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_94CDLEVENINGDOJISTAR};
+static PyObject *__pyx_pw_5talib_7_ta_lib_95CDLEVENINGDOJISTAR(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_open = 0;
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
+  double __pyx_v_penetration;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[5] = {0,0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("CDLINNECK (wrapper)", 0);
+  __Pyx_RefNannySetupContext("CDLEVENINGDOJISTAR (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,&__pyx_mstate_global->__pyx_n_u_penetration,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 1378, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  5:
+        values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(4, 1378, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1378, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1378, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  0: break;
-        default: goto __pyx_L5_argtuple_error;
-      }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1378, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLINNECK", 1, 4, 4, 1); __PYX_ERR(2, 1730, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLINNECK", 1, 4, 4, 2); __PYX_ERR(2, 1730, __pyx_L3_error)
-        }
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1378, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLINNECK", 1, 4, 4, 3); __PYX_ERR(2, 1730, __pyx_L3_error)
-        }
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
       }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "CDLINNECK") < 0)) __PYX_ERR(2, 1730, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLEVENINGDOJISTAR", 0) < (0)) __PYX_ERR(4, 1378, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLEVENINGDOJISTAR", 0, 4, 5, i); __PYX_ERR(4, 1378, __pyx_L3_error) }
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
-      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);
+      switch (__pyx_nargs) {
+        case  5:
+        values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(4, 1378, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1378, __pyx_L3_error)
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1378, __pyx_L3_error)
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1378, __pyx_L3_error)
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1378, __pyx_L3_error)
+        break;
+        default: goto __pyx_L5_argtuple_error;
+      }
     }
     __pyx_v_open = ((PyArrayObject *)values[0]);
     __pyx_v_high = ((PyArrayObject *)values[1]);
     __pyx_v_low = ((PyArrayObject *)values[2]);
     __pyx_v_close = ((PyArrayObject *)values[3]);
+    if (values[4]) {
+      __pyx_v_penetration = __Pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_penetration == (double)-1) && PyErr_Occurred())) __PYX_ERR(4, 1380, __pyx_L3_error)
+    } else {
+      __pyx_v_penetration = ((double)((double)0.3));
+    }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("CDLINNECK", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 1730, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("CDLEVENINGDOJISTAR", 0, 4, 5, __pyx_nargs); __PYX_ERR(4, 1378, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.CDLINNECK", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.CDLEVENINGDOJISTAR", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(2, 1730, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(2, 1730, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(2, 1730, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(2, 1730, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_116CDLINNECK(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 1380, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 1380, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 1380, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 1380, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_94CDLEVENINGDOJISTAR(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_penetration);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_116CDLINNECK(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_94CDLEVENINGDOJISTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -14785,55 +16513,58 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_116CDLINNECK(CYTHON_UNUSED PyObject *_
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
   npy_int __pyx_t_3;
-  __Pyx_RefNannySetupContext("CDLINNECK", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("CDLEVENINGDOJISTAR", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_open);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1747, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1399, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1748, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1400, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1749, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1401, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1750, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1402, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(2, 1751, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 1403, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
-  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_v_open->data), ((double *)__pyx_v_high->data), ((double *)__pyx_v_low->data), ((double *)__pyx_v_close->data)); if (unlikely(__pyx_t_3 == ((npy_int)-1))) __PYX_ERR(2, 1752, __pyx_L1_error)
+  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 1404, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_3;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLINNECK_Lookback());
+  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLEVENINGDOJISTAR_Lookback(__pyx_v_penetration));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1755, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1407, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_CDLINNECK(0, __pyx_v_endidx, (((double *)__pyx_v_open->data) + __pyx_v_begidx), (((double *)__pyx_v_high->data) + __pyx_v_begidx), (((double *)__pyx_v_low->data) + __pyx_v_begidx), (((double *)__pyx_v_close->data) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_v_outinteger->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_CDLEVENINGDOJISTAR(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), __pyx_v_penetration, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLINNECK, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1757, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLEVENINGDOJISTAR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1409, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outinteger));
+  __Pyx_INCREF((PyObject *)__pyx_v_outinteger);
   __pyx_r = ((PyObject *)__pyx_v_outinteger);
   goto __pyx_L0;
 
@@ -14841,7 +16572,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_116CDLINNECK(CYTHON_UNUSED PyObject *_
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.CDLINNECK", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.CDLEVENINGDOJISTAR", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_outinteger);
@@ -14856,99 +16587,146 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_116CDLINNECK(CYTHON_UNUSED PyObject *_
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_119CDLINVERTEDHAMMER(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_118CDLINVERTEDHAMMER[] = " CDLINVERTEDHAMMER(open, high, low, close)\n\n    Inverted Hammer (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_119CDLINVERTEDHAMMER = {"CDLINVERTEDHAMMER", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_119CDLINVERTEDHAMMER, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_118CDLINVERTEDHAMMER};
-static PyObject *__pyx_pw_5talib_7_ta_lib_119CDLINVERTEDHAMMER(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_97CDLEVENINGSTAR(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_96CDLEVENINGSTAR, "CDLEVENINGSTAR(ndarray open, ndarray high, ndarray low, ndarray close, double penetration=0.3)\n\nCDLEVENINGSTAR(open, high, low, close[, penetration=?])\n\nEvening Star (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nParameters:\n    penetration: 0.3\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_97CDLEVENINGSTAR = {"CDLEVENINGSTAR", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_97CDLEVENINGSTAR, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_96CDLEVENINGSTAR};
+static PyObject *__pyx_pw_5talib_7_ta_lib_97CDLEVENINGSTAR(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_open = 0;
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
+  double __pyx_v_penetration;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[5] = {0,0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("CDLINVERTEDHAMMER (wrapper)", 0);
+  __Pyx_RefNannySetupContext("CDLEVENINGSTAR (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,&__pyx_mstate_global->__pyx_n_u_penetration,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 1412, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  5:
+        values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(4, 1412, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1412, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1412, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  0: break;
-        default: goto __pyx_L5_argtuple_error;
-      }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1412, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLINVERTEDHAMMER", 1, 4, 4, 1); __PYX_ERR(2, 1762, __pyx_L3_error)
-        }
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1412, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLINVERTEDHAMMER", 1, 4, 4, 2); __PYX_ERR(2, 1762, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLINVERTEDHAMMER", 1, 4, 4, 3); __PYX_ERR(2, 1762, __pyx_L3_error)
-        }
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
       }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "CDLINVERTEDHAMMER") < 0)) __PYX_ERR(2, 1762, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLEVENINGSTAR", 0) < (0)) __PYX_ERR(4, 1412, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLEVENINGSTAR", 0, 4, 5, i); __PYX_ERR(4, 1412, __pyx_L3_error) }
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
-      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);
+      switch (__pyx_nargs) {
+        case  5:
+        values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(4, 1412, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1412, __pyx_L3_error)
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1412, __pyx_L3_error)
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1412, __pyx_L3_error)
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1412, __pyx_L3_error)
+        break;
+        default: goto __pyx_L5_argtuple_error;
+      }
     }
     __pyx_v_open = ((PyArrayObject *)values[0]);
     __pyx_v_high = ((PyArrayObject *)values[1]);
     __pyx_v_low = ((PyArrayObject *)values[2]);
     __pyx_v_close = ((PyArrayObject *)values[3]);
+    if (values[4]) {
+      __pyx_v_penetration = __Pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_penetration == (double)-1) && PyErr_Occurred())) __PYX_ERR(4, 1414, __pyx_L3_error)
+    } else {
+      __pyx_v_penetration = ((double)((double)0.3));
+    }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("CDLINVERTEDHAMMER", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 1762, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("CDLEVENINGSTAR", 0, 4, 5, __pyx_nargs); __PYX_ERR(4, 1412, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.CDLINVERTEDHAMMER", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.CDLEVENINGSTAR", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(2, 1762, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(2, 1762, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(2, 1762, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(2, 1762, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_118CDLINVERTEDHAMMER(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 1414, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 1414, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 1414, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 1414, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_96CDLEVENINGSTAR(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_penetration);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_118CDLINVERTEDHAMMER(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_96CDLEVENINGSTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -14962,55 +16740,58 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_118CDLINVERTEDHAMMER(CYTHON_UNUSED PyO
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
   npy_int __pyx_t_3;
-  __Pyx_RefNannySetupContext("CDLINVERTEDHAMMER", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("CDLEVENINGSTAR", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_open);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1779, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1433, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1780, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1434, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1781, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1435, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1782, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1436, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(2, 1783, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 1437, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
-  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_v_open->data), ((double *)__pyx_v_high->data), ((double *)__pyx_v_low->data), ((double *)__pyx_v_close->data)); if (unlikely(__pyx_t_3 == ((npy_int)-1))) __PYX_ERR(2, 1784, __pyx_L1_error)
+  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 1438, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_3;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLINVERTEDHAMMER_Lookback());
+  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLEVENINGSTAR_Lookback(__pyx_v_penetration));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1787, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1441, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_CDLINVERTEDHAMMER(0, __pyx_v_endidx, (((double *)__pyx_v_open->data) + __pyx_v_begidx), (((double *)__pyx_v_high->data) + __pyx_v_begidx), (((double *)__pyx_v_low->data) + __pyx_v_begidx), (((double *)__pyx_v_close->data) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_v_outinteger->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_CDLEVENINGSTAR(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), __pyx_v_penetration, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLINVERTEDHAMMER, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1789, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLEVENINGSTAR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1443, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outinteger));
+  __Pyx_INCREF((PyObject *)__pyx_v_outinteger);
   __pyx_r = ((PyObject *)__pyx_v_outinteger);
   goto __pyx_L0;
 
@@ -15018,7 +16799,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_118CDLINVERTEDHAMMER(CYTHON_UNUSED PyO
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.CDLINVERTEDHAMMER", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.CDLEVENINGSTAR", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_outinteger);
@@ -15033,99 +16814,129 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_118CDLINVERTEDHAMMER(CYTHON_UNUSED PyO
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_121CDLKICKING(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_120CDLKICKING[] = " CDLKICKING(open, high, low, close)\n\n    Kicking (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_121CDLKICKING = {"CDLKICKING", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_121CDLKICKING, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_120CDLKICKING};
-static PyObject *__pyx_pw_5talib_7_ta_lib_121CDLKICKING(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_99CDLGAPSIDESIDEWHITE(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_98CDLGAPSIDESIDEWHITE, "CDLGAPSIDESIDEWHITE(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLGAPSIDESIDEWHITE(open, high, low, close)\n\nUp/Down-gap side-by-side white lines (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_99CDLGAPSIDESIDEWHITE = {"CDLGAPSIDESIDEWHITE", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_99CDLGAPSIDESIDEWHITE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_98CDLGAPSIDESIDEWHITE};
+static PyObject *__pyx_pw_5talib_7_ta_lib_99CDLGAPSIDESIDEWHITE(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_open = 0;
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("CDLKICKING (wrapper)", 0);
+  __Pyx_RefNannySetupContext("CDLGAPSIDESIDEWHITE (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 1446, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1446, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1446, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1446, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1446, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLKICKING", 1, 4, 4, 1); __PYX_ERR(2, 1794, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLKICKING", 1, 4, 4, 2); __PYX_ERR(2, 1794, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLKICKING", 1, 4, 4, 3); __PYX_ERR(2, 1794, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "CDLKICKING") < 0)) __PYX_ERR(2, 1794, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLGAPSIDESIDEWHITE", 0) < (0)) __PYX_ERR(4, 1446, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLGAPSIDESIDEWHITE", 1, 4, 4, i); __PYX_ERR(4, 1446, __pyx_L3_error) }
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
+    } else if (unlikely(__pyx_nargs != 4)) {
       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[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1446, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1446, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1446, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1446, __pyx_L3_error)
     }
     __pyx_v_open = ((PyArrayObject *)values[0]);
     __pyx_v_high = ((PyArrayObject *)values[1]);
     __pyx_v_low = ((PyArrayObject *)values[2]);
     __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("CDLKICKING", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 1794, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("CDLGAPSIDESIDEWHITE", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 1446, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.CDLKICKING", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.CDLGAPSIDESIDEWHITE", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(2, 1794, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(2, 1794, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(2, 1794, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(2, 1794, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_120CDLKICKING(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 1448, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 1448, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 1448, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 1448, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_98CDLGAPSIDESIDEWHITE(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_120CDLKICKING(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_98CDLGAPSIDESIDEWHITE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -15139,55 +16950,58 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_120CDLKICKING(CYTHON_UNUSED PyObject *
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
   npy_int __pyx_t_3;
-  __Pyx_RefNannySetupContext("CDLKICKING", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("CDLGAPSIDESIDEWHITE", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_open);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1811, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1465, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1812, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1466, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1813, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1467, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1814, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1468, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(2, 1815, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 1469, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
-  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_v_open->data), ((double *)__pyx_v_high->data), ((double *)__pyx_v_low->data), ((double *)__pyx_v_close->data)); if (unlikely(__pyx_t_3 == ((npy_int)-1))) __PYX_ERR(2, 1816, __pyx_L1_error)
+  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 1470, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_3;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLKICKING_Lookback());
+  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLGAPSIDESIDEWHITE_Lookback());
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1819, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1473, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_CDLKICKING(0, __pyx_v_endidx, (((double *)__pyx_v_open->data) + __pyx_v_begidx), (((double *)__pyx_v_high->data) + __pyx_v_begidx), (((double *)__pyx_v_low->data) + __pyx_v_begidx), (((double *)__pyx_v_close->data) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_v_outinteger->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_CDLGAPSIDESIDEWHITE(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLKICKING, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1821, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLGAPSIDESIDEWHITE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1475, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outinteger));
+  __Pyx_INCREF((PyObject *)__pyx_v_outinteger);
   __pyx_r = ((PyObject *)__pyx_v_outinteger);
   goto __pyx_L0;
 
@@ -15195,7 +17009,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_120CDLKICKING(CYTHON_UNUSED PyObject *
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.CDLKICKING", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.CDLGAPSIDESIDEWHITE", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_outinteger);
@@ -15210,99 +17024,129 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_120CDLKICKING(CYTHON_UNUSED PyObject *
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_123CDLKICKINGBYLENGTH(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_122CDLKICKINGBYLENGTH[] = " CDLKICKINGBYLENGTH(open, high, low, close)\n\n    Kicking - bull/bear determined by the longer marubozu (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_123CDLKICKINGBYLENGTH = {"CDLKICKINGBYLENGTH", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_123CDLKICKINGBYLENGTH, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_122CDLKICKINGBYLENGTH};
-static PyObject *__pyx_pw_5talib_7_ta_lib_123CDLKICKINGBYLENGTH(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_101CDLGRAVESTONEDOJI(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_100CDLGRAVESTONEDOJI, "CDLGRAVESTONEDOJI(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLGRAVESTONEDOJI(open, high, low, close)\n\nGravestone Doji (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_101CDLGRAVESTONEDOJI = {"CDLGRAVESTONEDOJI", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_101CDLGRAVESTONEDOJI, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_100CDLGRAVESTONEDOJI};
+static PyObject *__pyx_pw_5talib_7_ta_lib_101CDLGRAVESTONEDOJI(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_open = 0;
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("CDLKICKINGBYLENGTH (wrapper)", 0);
+  __Pyx_RefNannySetupContext("CDLGRAVESTONEDOJI (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 1478, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1478, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1478, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1478, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1478, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLKICKINGBYLENGTH", 1, 4, 4, 1); __PYX_ERR(2, 1826, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLKICKINGBYLENGTH", 1, 4, 4, 2); __PYX_ERR(2, 1826, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLKICKINGBYLENGTH", 1, 4, 4, 3); __PYX_ERR(2, 1826, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "CDLKICKINGBYLENGTH") < 0)) __PYX_ERR(2, 1826, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLGRAVESTONEDOJI", 0) < (0)) __PYX_ERR(4, 1478, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLGRAVESTONEDOJI", 1, 4, 4, i); __PYX_ERR(4, 1478, __pyx_L3_error) }
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
+    } else if (unlikely(__pyx_nargs != 4)) {
       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[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1478, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1478, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1478, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1478, __pyx_L3_error)
     }
     __pyx_v_open = ((PyArrayObject *)values[0]);
     __pyx_v_high = ((PyArrayObject *)values[1]);
     __pyx_v_low = ((PyArrayObject *)values[2]);
     __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("CDLKICKINGBYLENGTH", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 1826, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("CDLGRAVESTONEDOJI", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 1478, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.CDLKICKINGBYLENGTH", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.CDLGRAVESTONEDOJI", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(2, 1826, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(2, 1826, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(2, 1826, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(2, 1826, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_122CDLKICKINGBYLENGTH(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 1480, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 1480, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 1480, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 1480, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_100CDLGRAVESTONEDOJI(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_122CDLKICKINGBYLENGTH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_100CDLGRAVESTONEDOJI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -15316,55 +17160,58 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_122CDLKICKINGBYLENGTH(CYTHON_UNUSED Py
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
   npy_int __pyx_t_3;
-  __Pyx_RefNannySetupContext("CDLKICKINGBYLENGTH", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("CDLGRAVESTONEDOJI", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_open);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1843, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1497, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1844, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1498, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1845, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1499, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1846, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1500, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(2, 1847, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 1501, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
-  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_v_open->data), ((double *)__pyx_v_high->data), ((double *)__pyx_v_low->data), ((double *)__pyx_v_close->data)); if (unlikely(__pyx_t_3 == ((npy_int)-1))) __PYX_ERR(2, 1848, __pyx_L1_error)
+  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 1502, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_3;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLKICKINGBYLENGTH_Lookback());
+  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLGRAVESTONEDOJI_Lookback());
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1851, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1505, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_CDLKICKINGBYLENGTH(0, __pyx_v_endidx, (((double *)__pyx_v_open->data) + __pyx_v_begidx), (((double *)__pyx_v_high->data) + __pyx_v_begidx), (((double *)__pyx_v_low->data) + __pyx_v_begidx), (((double *)__pyx_v_close->data) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_v_outinteger->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_CDLGRAVESTONEDOJI(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLKICKINGBYLENGTH, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1853, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLGRAVESTONEDOJI, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1507, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outinteger));
+  __Pyx_INCREF((PyObject *)__pyx_v_outinteger);
   __pyx_r = ((PyObject *)__pyx_v_outinteger);
   goto __pyx_L0;
 
@@ -15372,7 +17219,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_122CDLKICKINGBYLENGTH(CYTHON_UNUSED Py
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.CDLKICKINGBYLENGTH", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.CDLGRAVESTONEDOJI", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_outinteger);
@@ -15387,99 +17234,129 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_122CDLKICKINGBYLENGTH(CYTHON_UNUSED Py
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_125CDLLADDERBOTTOM(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_124CDLLADDERBOTTOM[] = " CDLLADDERBOTTOM(open, high, low, close)\n\n    Ladder Bottom (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_125CDLLADDERBOTTOM = {"CDLLADDERBOTTOM", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_125CDLLADDERBOTTOM, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_124CDLLADDERBOTTOM};
-static PyObject *__pyx_pw_5talib_7_ta_lib_125CDLLADDERBOTTOM(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_103CDLHAMMER(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_102CDLHAMMER, "CDLHAMMER(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLHAMMER(open, high, low, close)\n\nHammer (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_103CDLHAMMER = {"CDLHAMMER", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_103CDLHAMMER, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_102CDLHAMMER};
+static PyObject *__pyx_pw_5talib_7_ta_lib_103CDLHAMMER(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_open = 0;
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("CDLLADDERBOTTOM (wrapper)", 0);
+  __Pyx_RefNannySetupContext("CDLHAMMER (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 1510, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1510, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1510, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1510, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1510, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLLADDERBOTTOM", 1, 4, 4, 1); __PYX_ERR(2, 1858, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLLADDERBOTTOM", 1, 4, 4, 2); __PYX_ERR(2, 1858, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLLADDERBOTTOM", 1, 4, 4, 3); __PYX_ERR(2, 1858, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "CDLLADDERBOTTOM") < 0)) __PYX_ERR(2, 1858, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLHAMMER", 0) < (0)) __PYX_ERR(4, 1510, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLHAMMER", 1, 4, 4, i); __PYX_ERR(4, 1510, __pyx_L3_error) }
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
+    } else if (unlikely(__pyx_nargs != 4)) {
       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[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1510, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1510, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1510, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1510, __pyx_L3_error)
     }
     __pyx_v_open = ((PyArrayObject *)values[0]);
     __pyx_v_high = ((PyArrayObject *)values[1]);
     __pyx_v_low = ((PyArrayObject *)values[2]);
     __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("CDLLADDERBOTTOM", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 1858, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("CDLHAMMER", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 1510, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.CDLLADDERBOTTOM", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.CDLHAMMER", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(2, 1858, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(2, 1858, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(2, 1858, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(2, 1858, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_124CDLLADDERBOTTOM(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 1512, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 1512, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 1512, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 1512, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_102CDLHAMMER(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_124CDLLADDERBOTTOM(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_102CDLHAMMER(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -15493,55 +17370,58 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_124CDLLADDERBOTTOM(CYTHON_UNUSED PyObj
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
   npy_int __pyx_t_3;
-  __Pyx_RefNannySetupContext("CDLLADDERBOTTOM", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("CDLHAMMER", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_open);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1875, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1529, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1876, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1530, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1877, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1531, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1878, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1532, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(2, 1879, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 1533, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
-  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_v_open->data), ((double *)__pyx_v_high->data), ((double *)__pyx_v_low->data), ((double *)__pyx_v_close->data)); if (unlikely(__pyx_t_3 == ((npy_int)-1))) __PYX_ERR(2, 1880, __pyx_L1_error)
+  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 1534, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_3;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLLADDERBOTTOM_Lookback());
+  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLHAMMER_Lookback());
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1883, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1537, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_CDLLADDERBOTTOM(0, __pyx_v_endidx, (((double *)__pyx_v_open->data) + __pyx_v_begidx), (((double *)__pyx_v_high->data) + __pyx_v_begidx), (((double *)__pyx_v_low->data) + __pyx_v_begidx), (((double *)__pyx_v_close->data) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_v_outinteger->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_CDLHAMMER(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLLADDERBOTTOM, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1885, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLHAMMER, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1539, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outinteger));
+  __Pyx_INCREF((PyObject *)__pyx_v_outinteger);
   __pyx_r = ((PyObject *)__pyx_v_outinteger);
   goto __pyx_L0;
 
@@ -15549,7 +17429,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_124CDLLADDERBOTTOM(CYTHON_UNUSED PyObj
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.CDLLADDERBOTTOM", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.CDLHAMMER", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_outinteger);
@@ -15564,99 +17444,129 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_124CDLLADDERBOTTOM(CYTHON_UNUSED PyObj
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_127CDLLONGLEGGEDDOJI(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_126CDLLONGLEGGEDDOJI[] = " CDLLONGLEGGEDDOJI(open, high, low, close)\n\n    Long Legged Doji (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_127CDLLONGLEGGEDDOJI = {"CDLLONGLEGGEDDOJI", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_127CDLLONGLEGGEDDOJI, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_126CDLLONGLEGGEDDOJI};
-static PyObject *__pyx_pw_5talib_7_ta_lib_127CDLLONGLEGGEDDOJI(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_105CDLHANGINGMAN(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_104CDLHANGINGMAN, "CDLHANGINGMAN(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLHANGINGMAN(open, high, low, close)\n\nHanging Man (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_105CDLHANGINGMAN = {"CDLHANGINGMAN", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_105CDLHANGINGMAN, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_104CDLHANGINGMAN};
+static PyObject *__pyx_pw_5talib_7_ta_lib_105CDLHANGINGMAN(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_open = 0;
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("CDLLONGLEGGEDDOJI (wrapper)", 0);
+  __Pyx_RefNannySetupContext("CDLHANGINGMAN (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 1542, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1542, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1542, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1542, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1542, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLLONGLEGGEDDOJI", 1, 4, 4, 1); __PYX_ERR(2, 1890, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLLONGLEGGEDDOJI", 1, 4, 4, 2); __PYX_ERR(2, 1890, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLLONGLEGGEDDOJI", 1, 4, 4, 3); __PYX_ERR(2, 1890, __pyx_L3_error)
-        }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLHANGINGMAN", 0) < (0)) __PYX_ERR(4, 1542, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLHANGINGMAN", 1, 4, 4, i); __PYX_ERR(4, 1542, __pyx_L3_error) }
       }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "CDLLONGLEGGEDDOJI") < 0)) __PYX_ERR(2, 1890, __pyx_L3_error)
-      }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
+    } else if (unlikely(__pyx_nargs != 4)) {
       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[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1542, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1542, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1542, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1542, __pyx_L3_error)
     }
     __pyx_v_open = ((PyArrayObject *)values[0]);
     __pyx_v_high = ((PyArrayObject *)values[1]);
     __pyx_v_low = ((PyArrayObject *)values[2]);
     __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("CDLLONGLEGGEDDOJI", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 1890, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("CDLHANGINGMAN", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 1542, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.CDLLONGLEGGEDDOJI", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.CDLHANGINGMAN", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(2, 1890, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(2, 1890, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(2, 1890, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(2, 1890, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_126CDLLONGLEGGEDDOJI(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 1544, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 1544, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 1544, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 1544, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_104CDLHANGINGMAN(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_126CDLLONGLEGGEDDOJI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_104CDLHANGINGMAN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -15670,55 +17580,58 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_126CDLLONGLEGGEDDOJI(CYTHON_UNUSED PyO
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
   npy_int __pyx_t_3;
-  __Pyx_RefNannySetupContext("CDLLONGLEGGEDDOJI", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("CDLHANGINGMAN", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_open);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1907, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1561, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1908, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1562, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1909, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1563, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1910, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1564, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(2, 1911, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 1565, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
-  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_v_open->data), ((double *)__pyx_v_high->data), ((double *)__pyx_v_low->data), ((double *)__pyx_v_close->data)); if (unlikely(__pyx_t_3 == ((npy_int)-1))) __PYX_ERR(2, 1912, __pyx_L1_error)
+  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 1566, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_3;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLLONGLEGGEDDOJI_Lookback());
+  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLHANGINGMAN_Lookback());
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1915, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1569, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_CDLLONGLEGGEDDOJI(0, __pyx_v_endidx, (((double *)__pyx_v_open->data) + __pyx_v_begidx), (((double *)__pyx_v_high->data) + __pyx_v_begidx), (((double *)__pyx_v_low->data) + __pyx_v_begidx), (((double *)__pyx_v_close->data) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_v_outinteger->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_CDLHANGINGMAN(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLLONGLEGGEDDOJI, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1917, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLHANGINGMAN, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1571, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outinteger));
+  __Pyx_INCREF((PyObject *)__pyx_v_outinteger);
   __pyx_r = ((PyObject *)__pyx_v_outinteger);
   goto __pyx_L0;
 
@@ -15726,7 +17639,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_126CDLLONGLEGGEDDOJI(CYTHON_UNUSED PyO
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.CDLLONGLEGGEDDOJI", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.CDLHANGINGMAN", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_outinteger);
@@ -15741,99 +17654,129 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_126CDLLONGLEGGEDDOJI(CYTHON_UNUSED PyO
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_129CDLLONGLINE(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_128CDLLONGLINE[] = " CDLLONGLINE(open, high, low, close)\n\n    Long Line Candle (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_129CDLLONGLINE = {"CDLLONGLINE", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_129CDLLONGLINE, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_128CDLLONGLINE};
-static PyObject *__pyx_pw_5talib_7_ta_lib_129CDLLONGLINE(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_107CDLHARAMI(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_106CDLHARAMI, "CDLHARAMI(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLHARAMI(open, high, low, close)\n\nHarami Pattern (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_107CDLHARAMI = {"CDLHARAMI", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_107CDLHARAMI, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_106CDLHARAMI};
+static PyObject *__pyx_pw_5talib_7_ta_lib_107CDLHARAMI(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_open = 0;
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("CDLLONGLINE (wrapper)", 0);
+  __Pyx_RefNannySetupContext("CDLHARAMI (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 1574, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1574, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1574, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1574, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1574, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLLONGLINE", 1, 4, 4, 1); __PYX_ERR(2, 1922, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLLONGLINE", 1, 4, 4, 2); __PYX_ERR(2, 1922, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLLONGLINE", 1, 4, 4, 3); __PYX_ERR(2, 1922, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "CDLLONGLINE") < 0)) __PYX_ERR(2, 1922, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLHARAMI", 0) < (0)) __PYX_ERR(4, 1574, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLHARAMI", 1, 4, 4, i); __PYX_ERR(4, 1574, __pyx_L3_error) }
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
+    } else if (unlikely(__pyx_nargs != 4)) {
       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[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1574, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1574, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1574, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1574, __pyx_L3_error)
     }
     __pyx_v_open = ((PyArrayObject *)values[0]);
     __pyx_v_high = ((PyArrayObject *)values[1]);
     __pyx_v_low = ((PyArrayObject *)values[2]);
     __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("CDLLONGLINE", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 1922, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("CDLHARAMI", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 1574, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.CDLLONGLINE", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.CDLHARAMI", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(2, 1922, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(2, 1922, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(2, 1922, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(2, 1922, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_128CDLLONGLINE(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 1576, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 1576, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 1576, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 1576, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_106CDLHARAMI(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_128CDLLONGLINE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_106CDLHARAMI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -15847,55 +17790,58 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_128CDLLONGLINE(CYTHON_UNUSED PyObject
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
   npy_int __pyx_t_3;
-  __Pyx_RefNannySetupContext("CDLLONGLINE", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("CDLHARAMI", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_open);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1939, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1593, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1940, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1594, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1941, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1595, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1942, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1596, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(2, 1943, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 1597, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
-  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_v_open->data), ((double *)__pyx_v_high->data), ((double *)__pyx_v_low->data), ((double *)__pyx_v_close->data)); if (unlikely(__pyx_t_3 == ((npy_int)-1))) __PYX_ERR(2, 1944, __pyx_L1_error)
+  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 1598, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_3;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLLONGLINE_Lookback());
+  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLHARAMI_Lookback());
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1947, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1601, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_CDLLONGLINE(0, __pyx_v_endidx, (((double *)__pyx_v_open->data) + __pyx_v_begidx), (((double *)__pyx_v_high->data) + __pyx_v_begidx), (((double *)__pyx_v_low->data) + __pyx_v_begidx), (((double *)__pyx_v_close->data) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_v_outinteger->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_CDLHARAMI(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLLONGLINE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1949, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLHARAMI, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1603, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outinteger));
+  __Pyx_INCREF((PyObject *)__pyx_v_outinteger);
   __pyx_r = ((PyObject *)__pyx_v_outinteger);
   goto __pyx_L0;
 
@@ -15903,7 +17849,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_128CDLLONGLINE(CYTHON_UNUSED PyObject
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.CDLLONGLINE", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.CDLHARAMI", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_outinteger);
@@ -15918,99 +17864,129 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_128CDLLONGLINE(CYTHON_UNUSED PyObject
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_131CDLMARUBOZU(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_130CDLMARUBOZU[] = " CDLMARUBOZU(open, high, low, close)\n\n    Marubozu (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_131CDLMARUBOZU = {"CDLMARUBOZU", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_131CDLMARUBOZU, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_130CDLMARUBOZU};
-static PyObject *__pyx_pw_5talib_7_ta_lib_131CDLMARUBOZU(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_109CDLHARAMICROSS(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_108CDLHARAMICROSS, "CDLHARAMICROSS(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLHARAMICROSS(open, high, low, close)\n\nHarami Cross Pattern (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_109CDLHARAMICROSS = {"CDLHARAMICROSS", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_109CDLHARAMICROSS, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_108CDLHARAMICROSS};
+static PyObject *__pyx_pw_5talib_7_ta_lib_109CDLHARAMICROSS(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_open = 0;
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("CDLMARUBOZU (wrapper)", 0);
+  __Pyx_RefNannySetupContext("CDLHARAMICROSS (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 1606, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1606, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1606, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1606, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1606, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLMARUBOZU", 1, 4, 4, 1); __PYX_ERR(2, 1954, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLMARUBOZU", 1, 4, 4, 2); __PYX_ERR(2, 1954, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLMARUBOZU", 1, 4, 4, 3); __PYX_ERR(2, 1954, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "CDLMARUBOZU") < 0)) __PYX_ERR(2, 1954, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLHARAMICROSS", 0) < (0)) __PYX_ERR(4, 1606, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLHARAMICROSS", 1, 4, 4, i); __PYX_ERR(4, 1606, __pyx_L3_error) }
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
+    } else if (unlikely(__pyx_nargs != 4)) {
       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[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1606, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1606, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1606, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1606, __pyx_L3_error)
     }
     __pyx_v_open = ((PyArrayObject *)values[0]);
     __pyx_v_high = ((PyArrayObject *)values[1]);
     __pyx_v_low = ((PyArrayObject *)values[2]);
     __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("CDLMARUBOZU", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 1954, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("CDLHARAMICROSS", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 1606, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.CDLMARUBOZU", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.CDLHARAMICROSS", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(2, 1954, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(2, 1954, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(2, 1954, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(2, 1954, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_130CDLMARUBOZU(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 1608, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 1608, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 1608, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 1608, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_108CDLHARAMICROSS(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_130CDLMARUBOZU(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_108CDLHARAMICROSS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -16024,55 +18000,58 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_130CDLMARUBOZU(CYTHON_UNUSED PyObject
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
   npy_int __pyx_t_3;
-  __Pyx_RefNannySetupContext("CDLMARUBOZU", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("CDLHARAMICROSS", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_open);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1971, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1625, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1972, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1626, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1973, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1627, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1974, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1628, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(2, 1975, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 1629, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
-  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_v_open->data), ((double *)__pyx_v_high->data), ((double *)__pyx_v_low->data), ((double *)__pyx_v_close->data)); if (unlikely(__pyx_t_3 == ((npy_int)-1))) __PYX_ERR(2, 1976, __pyx_L1_error)
+  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 1630, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_3;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLMARUBOZU_Lookback());
+  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLHARAMICROSS_Lookback());
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1979, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1633, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_CDLMARUBOZU(0, __pyx_v_endidx, (((double *)__pyx_v_open->data) + __pyx_v_begidx), (((double *)__pyx_v_high->data) + __pyx_v_begidx), (((double *)__pyx_v_low->data) + __pyx_v_begidx), (((double *)__pyx_v_close->data) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_v_outinteger->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_CDLHARAMICROSS(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLMARUBOZU, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1981, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLHARAMICROSS, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1635, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outinteger));
+  __Pyx_INCREF((PyObject *)__pyx_v_outinteger);
   __pyx_r = ((PyObject *)__pyx_v_outinteger);
   goto __pyx_L0;
 
@@ -16080,7 +18059,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_130CDLMARUBOZU(CYTHON_UNUSED PyObject
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.CDLMARUBOZU", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.CDLHARAMICROSS", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_outinteger);
@@ -16095,99 +18074,129 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_130CDLMARUBOZU(CYTHON_UNUSED PyObject
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_133CDLMATCHINGLOW(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_132CDLMATCHINGLOW[] = " CDLMATCHINGLOW(open, high, low, close)\n\n    Matching Low (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_133CDLMATCHINGLOW = {"CDLMATCHINGLOW", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_133CDLMATCHINGLOW, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_132CDLMATCHINGLOW};
-static PyObject *__pyx_pw_5talib_7_ta_lib_133CDLMATCHINGLOW(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_111CDLHIGHWAVE(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_110CDLHIGHWAVE, "CDLHIGHWAVE(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLHIGHWAVE(open, high, low, close)\n\nHigh-Wave Candle (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_111CDLHIGHWAVE = {"CDLHIGHWAVE", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_111CDLHIGHWAVE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_110CDLHIGHWAVE};
+static PyObject *__pyx_pw_5talib_7_ta_lib_111CDLHIGHWAVE(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_open = 0;
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("CDLMATCHINGLOW (wrapper)", 0);
+  __Pyx_RefNannySetupContext("CDLHIGHWAVE (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 1638, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1638, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1638, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1638, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1638, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLMATCHINGLOW", 1, 4, 4, 1); __PYX_ERR(2, 1986, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLMATCHINGLOW", 1, 4, 4, 2); __PYX_ERR(2, 1986, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLMATCHINGLOW", 1, 4, 4, 3); __PYX_ERR(2, 1986, __pyx_L3_error)
-        }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLHIGHWAVE", 0) < (0)) __PYX_ERR(4, 1638, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLHIGHWAVE", 1, 4, 4, i); __PYX_ERR(4, 1638, __pyx_L3_error) }
       }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "CDLMATCHINGLOW") < 0)) __PYX_ERR(2, 1986, __pyx_L3_error)
-      }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
+    } else if (unlikely(__pyx_nargs != 4)) {
       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[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1638, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1638, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1638, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1638, __pyx_L3_error)
     }
     __pyx_v_open = ((PyArrayObject *)values[0]);
     __pyx_v_high = ((PyArrayObject *)values[1]);
     __pyx_v_low = ((PyArrayObject *)values[2]);
     __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("CDLMATCHINGLOW", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 1986, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("CDLHIGHWAVE", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 1638, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.CDLMATCHINGLOW", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.CDLHIGHWAVE", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(2, 1986, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(2, 1986, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(2, 1986, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(2, 1986, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_132CDLMATCHINGLOW(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 1640, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 1640, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 1640, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 1640, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_110CDLHIGHWAVE(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_132CDLMATCHINGLOW(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_110CDLHIGHWAVE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -16201,55 +18210,58 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_132CDLMATCHINGLOW(CYTHON_UNUSED PyObje
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
   npy_int __pyx_t_3;
-  __Pyx_RefNannySetupContext("CDLMATCHINGLOW", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("CDLHIGHWAVE", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_open);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2003, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1657, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2004, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1658, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2005, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1659, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2006, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1660, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(2, 2007, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 1661, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
-  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_v_open->data), ((double *)__pyx_v_high->data), ((double *)__pyx_v_low->data), ((double *)__pyx_v_close->data)); if (unlikely(__pyx_t_3 == ((npy_int)-1))) __PYX_ERR(2, 2008, __pyx_L1_error)
+  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 1662, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_3;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLMATCHINGLOW_Lookback());
+  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLHIGHWAVE_Lookback());
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2011, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1665, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_CDLMATCHINGLOW(0, __pyx_v_endidx, (((double *)__pyx_v_open->data) + __pyx_v_begidx), (((double *)__pyx_v_high->data) + __pyx_v_begidx), (((double *)__pyx_v_low->data) + __pyx_v_begidx), (((double *)__pyx_v_close->data) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_v_outinteger->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_CDLHIGHWAVE(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLMATCHINGLOW, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2013, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLHIGHWAVE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1667, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outinteger));
+  __Pyx_INCREF((PyObject *)__pyx_v_outinteger);
   __pyx_r = ((PyObject *)__pyx_v_outinteger);
   goto __pyx_L0;
 
@@ -16257,7 +18269,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_132CDLMATCHINGLOW(CYTHON_UNUSED PyObje
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.CDLMATCHINGLOW", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.CDLHIGHWAVE", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_outinteger);
@@ -16272,117 +18284,129 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_132CDLMATCHINGLOW(CYTHON_UNUSED PyObje
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_135CDLMATHOLD(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_134CDLMATHOLD[] = " CDLMATHOLD(open, high, low, close[, penetration=?])\n\n    Mat Hold (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Parameters:\n        penetration: 0.5\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_135CDLMATHOLD = {"CDLMATHOLD", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_135CDLMATHOLD, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_134CDLMATHOLD};
-static PyObject *__pyx_pw_5talib_7_ta_lib_135CDLMATHOLD(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_113CDLHIKKAKE(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_112CDLHIKKAKE, "CDLHIKKAKE(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLHIKKAKE(open, high, low, close)\n\nHikkake Pattern (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_113CDLHIKKAKE = {"CDLHIKKAKE", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_113CDLHIKKAKE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_112CDLHIKKAKE};
+static PyObject *__pyx_pw_5talib_7_ta_lib_113CDLHIKKAKE(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_open = 0;
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
-  double __pyx_v_penetration;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("CDLMATHOLD (wrapper)", 0);
+  __Pyx_RefNannySetupContext("CDLHIKKAKE (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,&__pyx_n_s_penetration,0};
-    PyObject* values[5] = {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  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
-        CYTHON_FALLTHROUGH;
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 1670, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1670, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1670, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1670, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1670, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLMATHOLD", 0, 4, 5, 1); __PYX_ERR(2, 2018, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLMATHOLD", 0, 4, 5, 2); __PYX_ERR(2, 2018, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLMATHOLD", 0, 4, 5, 3); __PYX_ERR(2, 2018, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  4:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_penetration);
-          if (value) { values[4] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "CDLMATHOLD") < 0)) __PYX_ERR(2, 2018, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLHIKKAKE", 0) < (0)) __PYX_ERR(4, 1670, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLHIKKAKE", 1, 4, 4, i); __PYX_ERR(4, 1670, __pyx_L3_error) }
       }
+    } else if (unlikely(__pyx_nargs != 4)) {
+      goto __pyx_L5_argtuple_error;
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
-        CYTHON_FALLTHROUGH;
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-        break;
-        default: goto __pyx_L5_argtuple_error;
-      }
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1670, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1670, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1670, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1670, __pyx_L3_error)
     }
     __pyx_v_open = ((PyArrayObject *)values[0]);
     __pyx_v_high = ((PyArrayObject *)values[1]);
     __pyx_v_low = ((PyArrayObject *)values[2]);
     __pyx_v_close = ((PyArrayObject *)values[3]);
-    if (values[4]) {
-      __pyx_v_penetration = __pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_penetration == (double)-1) && PyErr_Occurred())) __PYX_ERR(2, 2018, __pyx_L3_error)
-    } else {
-      __pyx_v_penetration = ((double)0.5);
-    }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("CDLMATHOLD", 0, 4, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 2018, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("CDLHIKKAKE", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 1670, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.CDLMATHOLD", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.CDLHIKKAKE", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(2, 2018, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(2, 2018, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(2, 2018, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(2, 2018, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_134CDLMATHOLD(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_penetration);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 1672, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 1672, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 1672, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 1672, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_112CDLHIKKAKE(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_134CDLMATHOLD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_112CDLHIKKAKE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -16396,55 +18420,58 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_134CDLMATHOLD(CYTHON_UNUSED PyObject *
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
   npy_int __pyx_t_3;
-  __Pyx_RefNannySetupContext("CDLMATHOLD", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("CDLHIKKAKE", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_open);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2037, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1689, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2038, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1690, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2039, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1691, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2040, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1692, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(2, 2041, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 1693, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
-  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_v_open->data), ((double *)__pyx_v_high->data), ((double *)__pyx_v_low->data), ((double *)__pyx_v_close->data)); if (unlikely(__pyx_t_3 == ((npy_int)-1))) __PYX_ERR(2, 2042, __pyx_L1_error)
+  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 1694, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_3;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLMATHOLD_Lookback(__pyx_v_penetration));
+  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLHIKKAKE_Lookback());
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2045, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1697, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_CDLMATHOLD(0, __pyx_v_endidx, (((double *)__pyx_v_open->data) + __pyx_v_begidx), (((double *)__pyx_v_high->data) + __pyx_v_begidx), (((double *)__pyx_v_low->data) + __pyx_v_begidx), (((double *)__pyx_v_close->data) + __pyx_v_begidx), __pyx_v_penetration, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_v_outinteger->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_CDLHIKKAKE(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLMATHOLD, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2047, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLHIKKAKE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1699, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outinteger));
+  __Pyx_INCREF((PyObject *)__pyx_v_outinteger);
   __pyx_r = ((PyObject *)__pyx_v_outinteger);
   goto __pyx_L0;
 
@@ -16452,7 +18479,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_134CDLMATHOLD(CYTHON_UNUSED PyObject *
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.CDLMATHOLD", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.CDLHIKKAKE", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_outinteger);
@@ -16467,117 +18494,129 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_134CDLMATHOLD(CYTHON_UNUSED PyObject *
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_137CDLMORNINGDOJISTAR(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_136CDLMORNINGDOJISTAR[] = " CDLMORNINGDOJISTAR(open, high, low, close[, penetration=?])\n\n    Morning Doji Star (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Parameters:\n        penetration: 0.3\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_137CDLMORNINGDOJISTAR = {"CDLMORNINGDOJISTAR", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_137CDLMORNINGDOJISTAR, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_136CDLMORNINGDOJISTAR};
-static PyObject *__pyx_pw_5talib_7_ta_lib_137CDLMORNINGDOJISTAR(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_115CDLHIKKAKEMOD(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_114CDLHIKKAKEMOD, "CDLHIKKAKEMOD(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLHIKKAKEMOD(open, high, low, close)\n\nModified Hikkake Pattern (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_115CDLHIKKAKEMOD = {"CDLHIKKAKEMOD", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_115CDLHIKKAKEMOD, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_114CDLHIKKAKEMOD};
+static PyObject *__pyx_pw_5talib_7_ta_lib_115CDLHIKKAKEMOD(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_open = 0;
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
-  double __pyx_v_penetration;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("CDLMORNINGDOJISTAR (wrapper)", 0);
+  __Pyx_RefNannySetupContext("CDLHIKKAKEMOD (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,&__pyx_n_s_penetration,0};
-    PyObject* values[5] = {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  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
-        CYTHON_FALLTHROUGH;
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 1702, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1702, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1702, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1702, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1702, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLMORNINGDOJISTAR", 0, 4, 5, 1); __PYX_ERR(2, 2052, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLMORNINGDOJISTAR", 0, 4, 5, 2); __PYX_ERR(2, 2052, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLMORNINGDOJISTAR", 0, 4, 5, 3); __PYX_ERR(2, 2052, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  4:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_penetration);
-          if (value) { values[4] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "CDLMORNINGDOJISTAR") < 0)) __PYX_ERR(2, 2052, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLHIKKAKEMOD", 0) < (0)) __PYX_ERR(4, 1702, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLHIKKAKEMOD", 1, 4, 4, i); __PYX_ERR(4, 1702, __pyx_L3_error) }
       }
+    } else if (unlikely(__pyx_nargs != 4)) {
+      goto __pyx_L5_argtuple_error;
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
-        CYTHON_FALLTHROUGH;
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-        break;
-        default: goto __pyx_L5_argtuple_error;
-      }
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1702, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1702, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1702, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1702, __pyx_L3_error)
     }
     __pyx_v_open = ((PyArrayObject *)values[0]);
     __pyx_v_high = ((PyArrayObject *)values[1]);
     __pyx_v_low = ((PyArrayObject *)values[2]);
     __pyx_v_close = ((PyArrayObject *)values[3]);
-    if (values[4]) {
-      __pyx_v_penetration = __pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_penetration == (double)-1) && PyErr_Occurred())) __PYX_ERR(2, 2052, __pyx_L3_error)
-    } else {
-      __pyx_v_penetration = ((double)0.3);
-    }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("CDLMORNINGDOJISTAR", 0, 4, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 2052, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("CDLHIKKAKEMOD", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 1702, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.CDLMORNINGDOJISTAR", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.CDLHIKKAKEMOD", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(2, 2052, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(2, 2052, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(2, 2052, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(2, 2052, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_136CDLMORNINGDOJISTAR(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_penetration);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 1704, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 1704, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 1704, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 1704, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_114CDLHIKKAKEMOD(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_136CDLMORNINGDOJISTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_114CDLHIKKAKEMOD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -16591,55 +18630,58 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_136CDLMORNINGDOJISTAR(CYTHON_UNUSED Py
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
   npy_int __pyx_t_3;
-  __Pyx_RefNannySetupContext("CDLMORNINGDOJISTAR", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("CDLHIKKAKEMOD", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_open);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2071, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1721, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2072, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1722, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2073, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1723, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2074, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1724, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(2, 2075, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 1725, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
-  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_v_open->data), ((double *)__pyx_v_high->data), ((double *)__pyx_v_low->data), ((double *)__pyx_v_close->data)); if (unlikely(__pyx_t_3 == ((npy_int)-1))) __PYX_ERR(2, 2076, __pyx_L1_error)
+  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 1726, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_3;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLMORNINGDOJISTAR_Lookback(__pyx_v_penetration));
+  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLHIKKAKEMOD_Lookback());
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2079, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1729, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_CDLMORNINGDOJISTAR(0, __pyx_v_endidx, (((double *)__pyx_v_open->data) + __pyx_v_begidx), (((double *)__pyx_v_high->data) + __pyx_v_begidx), (((double *)__pyx_v_low->data) + __pyx_v_begidx), (((double *)__pyx_v_close->data) + __pyx_v_begidx), __pyx_v_penetration, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_v_outinteger->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_CDLHIKKAKEMOD(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLMORNINGDOJISTAR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2081, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLHIKKAKEMOD, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1731, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outinteger));
+  __Pyx_INCREF((PyObject *)__pyx_v_outinteger);
   __pyx_r = ((PyObject *)__pyx_v_outinteger);
   goto __pyx_L0;
 
@@ -16647,7 +18689,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_136CDLMORNINGDOJISTAR(CYTHON_UNUSED Py
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.CDLMORNINGDOJISTAR", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.CDLHIKKAKEMOD", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_outinteger);
@@ -16662,117 +18704,129 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_136CDLMORNINGDOJISTAR(CYTHON_UNUSED Py
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_139CDLMORNINGSTAR(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_138CDLMORNINGSTAR[] = " CDLMORNINGSTAR(open, high, low, close[, penetration=?])\n\n    Morning Star (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Parameters:\n        penetration: 0.3\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_139CDLMORNINGSTAR = {"CDLMORNINGSTAR", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_139CDLMORNINGSTAR, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_138CDLMORNINGSTAR};
-static PyObject *__pyx_pw_5talib_7_ta_lib_139CDLMORNINGSTAR(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_117CDLHOMINGPIGEON(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_116CDLHOMINGPIGEON, "CDLHOMINGPIGEON(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLHOMINGPIGEON(open, high, low, close)\n\nHoming Pigeon (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_117CDLHOMINGPIGEON = {"CDLHOMINGPIGEON", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_117CDLHOMINGPIGEON, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_116CDLHOMINGPIGEON};
+static PyObject *__pyx_pw_5talib_7_ta_lib_117CDLHOMINGPIGEON(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_open = 0;
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
-  double __pyx_v_penetration;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("CDLMORNINGSTAR (wrapper)", 0);
+  __Pyx_RefNannySetupContext("CDLHOMINGPIGEON (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,&__pyx_n_s_penetration,0};
-    PyObject* values[5] = {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  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
-        CYTHON_FALLTHROUGH;
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 1734, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1734, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1734, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1734, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1734, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLMORNINGSTAR", 0, 4, 5, 1); __PYX_ERR(2, 2086, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLMORNINGSTAR", 0, 4, 5, 2); __PYX_ERR(2, 2086, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLMORNINGSTAR", 0, 4, 5, 3); __PYX_ERR(2, 2086, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  4:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_penetration);
-          if (value) { values[4] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "CDLMORNINGSTAR") < 0)) __PYX_ERR(2, 2086, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLHOMINGPIGEON", 0) < (0)) __PYX_ERR(4, 1734, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLHOMINGPIGEON", 1, 4, 4, i); __PYX_ERR(4, 1734, __pyx_L3_error) }
       }
+    } else if (unlikely(__pyx_nargs != 4)) {
+      goto __pyx_L5_argtuple_error;
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
-        CYTHON_FALLTHROUGH;
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-        break;
-        default: goto __pyx_L5_argtuple_error;
-      }
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1734, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1734, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1734, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1734, __pyx_L3_error)
     }
     __pyx_v_open = ((PyArrayObject *)values[0]);
     __pyx_v_high = ((PyArrayObject *)values[1]);
     __pyx_v_low = ((PyArrayObject *)values[2]);
     __pyx_v_close = ((PyArrayObject *)values[3]);
-    if (values[4]) {
-      __pyx_v_penetration = __pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_penetration == (double)-1) && PyErr_Occurred())) __PYX_ERR(2, 2086, __pyx_L3_error)
-    } else {
-      __pyx_v_penetration = ((double)0.3);
-    }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("CDLMORNINGSTAR", 0, 4, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 2086, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("CDLHOMINGPIGEON", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 1734, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.CDLMORNINGSTAR", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.CDLHOMINGPIGEON", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(2, 2086, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(2, 2086, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(2, 2086, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(2, 2086, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_138CDLMORNINGSTAR(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_penetration);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 1736, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 1736, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 1736, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 1736, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_116CDLHOMINGPIGEON(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_138CDLMORNINGSTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_116CDLHOMINGPIGEON(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -16786,55 +18840,58 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_138CDLMORNINGSTAR(CYTHON_UNUSED PyObje
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
   npy_int __pyx_t_3;
-  __Pyx_RefNannySetupContext("CDLMORNINGSTAR", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("CDLHOMINGPIGEON", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_open);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2105, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1753, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2106, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1754, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2107, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1755, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2108, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1756, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(2, 2109, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 1757, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
-  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_v_open->data), ((double *)__pyx_v_high->data), ((double *)__pyx_v_low->data), ((double *)__pyx_v_close->data)); if (unlikely(__pyx_t_3 == ((npy_int)-1))) __PYX_ERR(2, 2110, __pyx_L1_error)
+  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 1758, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_3;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLMORNINGSTAR_Lookback(__pyx_v_penetration));
+  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLHOMINGPIGEON_Lookback());
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2113, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1761, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_CDLMORNINGSTAR(0, __pyx_v_endidx, (((double *)__pyx_v_open->data) + __pyx_v_begidx), (((double *)__pyx_v_high->data) + __pyx_v_begidx), (((double *)__pyx_v_low->data) + __pyx_v_begidx), (((double *)__pyx_v_close->data) + __pyx_v_begidx), __pyx_v_penetration, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_v_outinteger->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_CDLHOMINGPIGEON(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLMORNINGSTAR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2115, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLHOMINGPIGEON, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1763, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outinteger));
+  __Pyx_INCREF((PyObject *)__pyx_v_outinteger);
   __pyx_r = ((PyObject *)__pyx_v_outinteger);
   goto __pyx_L0;
 
@@ -16842,7 +18899,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_138CDLMORNINGSTAR(CYTHON_UNUSED PyObje
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.CDLMORNINGSTAR", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.CDLHOMINGPIGEON", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_outinteger);
@@ -16857,99 +18914,129 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_138CDLMORNINGSTAR(CYTHON_UNUSED PyObje
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_141CDLONNECK(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_140CDLONNECK[] = " CDLONNECK(open, high, low, close)\n\n    On-Neck Pattern (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_141CDLONNECK = {"CDLONNECK", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_141CDLONNECK, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_140CDLONNECK};
-static PyObject *__pyx_pw_5talib_7_ta_lib_141CDLONNECK(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_119CDLIDENTICAL3CROWS(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_118CDLIDENTICAL3CROWS, "CDLIDENTICAL3CROWS(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLIDENTICAL3CROWS(open, high, low, close)\n\nIdentical Three Crows (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_119CDLIDENTICAL3CROWS = {"CDLIDENTICAL3CROWS", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_119CDLIDENTICAL3CROWS, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_118CDLIDENTICAL3CROWS};
+static PyObject *__pyx_pw_5talib_7_ta_lib_119CDLIDENTICAL3CROWS(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_open = 0;
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("CDLONNECK (wrapper)", 0);
+  __Pyx_RefNannySetupContext("CDLIDENTICAL3CROWS (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 1766, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1766, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1766, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1766, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1766, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLONNECK", 1, 4, 4, 1); __PYX_ERR(2, 2120, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLONNECK", 1, 4, 4, 2); __PYX_ERR(2, 2120, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLONNECK", 1, 4, 4, 3); __PYX_ERR(2, 2120, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "CDLONNECK") < 0)) __PYX_ERR(2, 2120, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLIDENTICAL3CROWS", 0) < (0)) __PYX_ERR(4, 1766, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLIDENTICAL3CROWS", 1, 4, 4, i); __PYX_ERR(4, 1766, __pyx_L3_error) }
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
+    } else if (unlikely(__pyx_nargs != 4)) {
       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[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1766, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1766, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1766, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1766, __pyx_L3_error)
     }
     __pyx_v_open = ((PyArrayObject *)values[0]);
     __pyx_v_high = ((PyArrayObject *)values[1]);
     __pyx_v_low = ((PyArrayObject *)values[2]);
     __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("CDLONNECK", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 2120, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("CDLIDENTICAL3CROWS", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 1766, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.CDLONNECK", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.CDLIDENTICAL3CROWS", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(2, 2120, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(2, 2120, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(2, 2120, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(2, 2120, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_140CDLONNECK(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 1768, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 1768, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 1768, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 1768, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_118CDLIDENTICAL3CROWS(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_140CDLONNECK(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_118CDLIDENTICAL3CROWS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -16963,55 +19050,58 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_140CDLONNECK(CYTHON_UNUSED PyObject *_
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
   npy_int __pyx_t_3;
-  __Pyx_RefNannySetupContext("CDLONNECK", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("CDLIDENTICAL3CROWS", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_open);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2137, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1785, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2138, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1786, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2139, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1787, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2140, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1788, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(2, 2141, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 1789, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
-  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_v_open->data), ((double *)__pyx_v_high->data), ((double *)__pyx_v_low->data), ((double *)__pyx_v_close->data)); if (unlikely(__pyx_t_3 == ((npy_int)-1))) __PYX_ERR(2, 2142, __pyx_L1_error)
+  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 1790, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_3;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLONNECK_Lookback());
+  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLIDENTICAL3CROWS_Lookback());
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2145, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1793, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_CDLONNECK(0, __pyx_v_endidx, (((double *)__pyx_v_open->data) + __pyx_v_begidx), (((double *)__pyx_v_high->data) + __pyx_v_begidx), (((double *)__pyx_v_low->data) + __pyx_v_begidx), (((double *)__pyx_v_close->data) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_v_outinteger->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_CDLIDENTICAL3CROWS(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLONNECK, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2147, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLIDENTICAL3CROWS, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1795, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outinteger));
+  __Pyx_INCREF((PyObject *)__pyx_v_outinteger);
   __pyx_r = ((PyObject *)__pyx_v_outinteger);
   goto __pyx_L0;
 
@@ -17019,7 +19109,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_140CDLONNECK(CYTHON_UNUSED PyObject *_
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.CDLONNECK", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.CDLIDENTICAL3CROWS", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_outinteger);
@@ -17034,99 +19124,129 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_140CDLONNECK(CYTHON_UNUSED PyObject *_
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_143CDLPIERCING(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_142CDLPIERCING[] = " CDLPIERCING(open, high, low, close)\n\n    Piercing Pattern (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_143CDLPIERCING = {"CDLPIERCING", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_143CDLPIERCING, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_142CDLPIERCING};
-static PyObject *__pyx_pw_5talib_7_ta_lib_143CDLPIERCING(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_121CDLINNECK(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_120CDLINNECK, "CDLINNECK(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLINNECK(open, high, low, close)\n\nIn-Neck Pattern (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_121CDLINNECK = {"CDLINNECK", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_121CDLINNECK, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_120CDLINNECK};
+static PyObject *__pyx_pw_5talib_7_ta_lib_121CDLINNECK(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_open = 0;
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("CDLPIERCING (wrapper)", 0);
+  __Pyx_RefNannySetupContext("CDLINNECK (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 1798, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1798, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1798, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1798, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1798, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLPIERCING", 1, 4, 4, 1); __PYX_ERR(2, 2152, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLPIERCING", 1, 4, 4, 2); __PYX_ERR(2, 2152, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLPIERCING", 1, 4, 4, 3); __PYX_ERR(2, 2152, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "CDLPIERCING") < 0)) __PYX_ERR(2, 2152, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLINNECK", 0) < (0)) __PYX_ERR(4, 1798, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLINNECK", 1, 4, 4, i); __PYX_ERR(4, 1798, __pyx_L3_error) }
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
+    } else if (unlikely(__pyx_nargs != 4)) {
       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[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1798, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1798, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1798, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1798, __pyx_L3_error)
     }
     __pyx_v_open = ((PyArrayObject *)values[0]);
     __pyx_v_high = ((PyArrayObject *)values[1]);
     __pyx_v_low = ((PyArrayObject *)values[2]);
     __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("CDLPIERCING", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 2152, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("CDLINNECK", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 1798, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.CDLPIERCING", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.CDLINNECK", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(2, 2152, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(2, 2152, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(2, 2152, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(2, 2152, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_142CDLPIERCING(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 1800, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 1800, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 1800, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 1800, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_120CDLINNECK(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_142CDLPIERCING(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_120CDLINNECK(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -17140,55 +19260,58 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_142CDLPIERCING(CYTHON_UNUSED PyObject
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
   npy_int __pyx_t_3;
-  __Pyx_RefNannySetupContext("CDLPIERCING", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("CDLINNECK", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_open);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2169, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1817, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2170, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1818, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2171, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1819, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2172, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1820, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(2, 2173, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 1821, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
-  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_v_open->data), ((double *)__pyx_v_high->data), ((double *)__pyx_v_low->data), ((double *)__pyx_v_close->data)); if (unlikely(__pyx_t_3 == ((npy_int)-1))) __PYX_ERR(2, 2174, __pyx_L1_error)
+  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 1822, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_3;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLPIERCING_Lookback());
+  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLINNECK_Lookback());
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2177, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1825, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_CDLPIERCING(0, __pyx_v_endidx, (((double *)__pyx_v_open->data) + __pyx_v_begidx), (((double *)__pyx_v_high->data) + __pyx_v_begidx), (((double *)__pyx_v_low->data) + __pyx_v_begidx), (((double *)__pyx_v_close->data) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_v_outinteger->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_CDLINNECK(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLPIERCING, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2179, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLINNECK, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1827, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outinteger));
+  __Pyx_INCREF((PyObject *)__pyx_v_outinteger);
   __pyx_r = ((PyObject *)__pyx_v_outinteger);
   goto __pyx_L0;
 
@@ -17196,7 +19319,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_142CDLPIERCING(CYTHON_UNUSED PyObject
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.CDLPIERCING", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.CDLINNECK", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_outinteger);
@@ -17211,99 +19334,129 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_142CDLPIERCING(CYTHON_UNUSED PyObject
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_145CDLRICKSHAWMAN(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_144CDLRICKSHAWMAN[] = " CDLRICKSHAWMAN(open, high, low, close)\n\n    Rickshaw Man (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_145CDLRICKSHAWMAN = {"CDLRICKSHAWMAN", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_145CDLRICKSHAWMAN, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_144CDLRICKSHAWMAN};
-static PyObject *__pyx_pw_5talib_7_ta_lib_145CDLRICKSHAWMAN(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_123CDLINVERTEDHAMMER(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_122CDLINVERTEDHAMMER, "CDLINVERTEDHAMMER(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLINVERTEDHAMMER(open, high, low, close)\n\nInverted Hammer (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_123CDLINVERTEDHAMMER = {"CDLINVERTEDHAMMER", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_123CDLINVERTEDHAMMER, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_122CDLINVERTEDHAMMER};
+static PyObject *__pyx_pw_5talib_7_ta_lib_123CDLINVERTEDHAMMER(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_open = 0;
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("CDLRICKSHAWMAN (wrapper)", 0);
+  __Pyx_RefNannySetupContext("CDLINVERTEDHAMMER (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 1830, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1830, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1830, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1830, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1830, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLRICKSHAWMAN", 1, 4, 4, 1); __PYX_ERR(2, 2184, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLRICKSHAWMAN", 1, 4, 4, 2); __PYX_ERR(2, 2184, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLRICKSHAWMAN", 1, 4, 4, 3); __PYX_ERR(2, 2184, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "CDLRICKSHAWMAN") < 0)) __PYX_ERR(2, 2184, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLINVERTEDHAMMER", 0) < (0)) __PYX_ERR(4, 1830, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLINVERTEDHAMMER", 1, 4, 4, i); __PYX_ERR(4, 1830, __pyx_L3_error) }
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
+    } else if (unlikely(__pyx_nargs != 4)) {
       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[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1830, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1830, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1830, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1830, __pyx_L3_error)
     }
     __pyx_v_open = ((PyArrayObject *)values[0]);
     __pyx_v_high = ((PyArrayObject *)values[1]);
     __pyx_v_low = ((PyArrayObject *)values[2]);
     __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("CDLRICKSHAWMAN", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 2184, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("CDLINVERTEDHAMMER", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 1830, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.CDLRICKSHAWMAN", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.CDLINVERTEDHAMMER", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(2, 2184, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(2, 2184, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(2, 2184, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(2, 2184, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_144CDLRICKSHAWMAN(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 1832, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 1832, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 1832, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 1832, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_122CDLINVERTEDHAMMER(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_144CDLRICKSHAWMAN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_122CDLINVERTEDHAMMER(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -17317,55 +19470,58 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_144CDLRICKSHAWMAN(CYTHON_UNUSED PyObje
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
   npy_int __pyx_t_3;
-  __Pyx_RefNannySetupContext("CDLRICKSHAWMAN", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("CDLINVERTEDHAMMER", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_open);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2201, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1849, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2202, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1850, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2203, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1851, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2204, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1852, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(2, 2205, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 1853, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
-  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_v_open->data), ((double *)__pyx_v_high->data), ((double *)__pyx_v_low->data), ((double *)__pyx_v_close->data)); if (unlikely(__pyx_t_3 == ((npy_int)-1))) __PYX_ERR(2, 2206, __pyx_L1_error)
+  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 1854, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_3;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLRICKSHAWMAN_Lookback());
+  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLINVERTEDHAMMER_Lookback());
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2209, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1857, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_CDLRICKSHAWMAN(0, __pyx_v_endidx, (((double *)__pyx_v_open->data) + __pyx_v_begidx), (((double *)__pyx_v_high->data) + __pyx_v_begidx), (((double *)__pyx_v_low->data) + __pyx_v_begidx), (((double *)__pyx_v_close->data) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_v_outinteger->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_CDLINVERTEDHAMMER(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLRICKSHAWMAN, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2211, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLINVERTEDHAMMER, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1859, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outinteger));
+  __Pyx_INCREF((PyObject *)__pyx_v_outinteger);
   __pyx_r = ((PyObject *)__pyx_v_outinteger);
   goto __pyx_L0;
 
@@ -17373,7 +19529,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_144CDLRICKSHAWMAN(CYTHON_UNUSED PyObje
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.CDLRICKSHAWMAN", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.CDLINVERTEDHAMMER", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_outinteger);
@@ -17388,99 +19544,129 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_144CDLRICKSHAWMAN(CYTHON_UNUSED PyObje
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_147CDLRISEFALL3METHODS(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_146CDLRISEFALL3METHODS[] = " CDLRISEFALL3METHODS(open, high, low, close)\n\n    Rising/Falling Three Methods (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_147CDLRISEFALL3METHODS = {"CDLRISEFALL3METHODS", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_147CDLRISEFALL3METHODS, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_146CDLRISEFALL3METHODS};
-static PyObject *__pyx_pw_5talib_7_ta_lib_147CDLRISEFALL3METHODS(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_125CDLKICKING(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_124CDLKICKING, "CDLKICKING(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLKICKING(open, high, low, close)\n\nKicking (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_125CDLKICKING = {"CDLKICKING", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_125CDLKICKING, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_124CDLKICKING};
+static PyObject *__pyx_pw_5talib_7_ta_lib_125CDLKICKING(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_open = 0;
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("CDLRISEFALL3METHODS (wrapper)", 0);
+  __Pyx_RefNannySetupContext("CDLKICKING (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 1862, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1862, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1862, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1862, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1862, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLRISEFALL3METHODS", 1, 4, 4, 1); __PYX_ERR(2, 2216, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLRISEFALL3METHODS", 1, 4, 4, 2); __PYX_ERR(2, 2216, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLRISEFALL3METHODS", 1, 4, 4, 3); __PYX_ERR(2, 2216, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "CDLRISEFALL3METHODS") < 0)) __PYX_ERR(2, 2216, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLKICKING", 0) < (0)) __PYX_ERR(4, 1862, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLKICKING", 1, 4, 4, i); __PYX_ERR(4, 1862, __pyx_L3_error) }
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
+    } else if (unlikely(__pyx_nargs != 4)) {
       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[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1862, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1862, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1862, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1862, __pyx_L3_error)
     }
     __pyx_v_open = ((PyArrayObject *)values[0]);
     __pyx_v_high = ((PyArrayObject *)values[1]);
     __pyx_v_low = ((PyArrayObject *)values[2]);
     __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("CDLRISEFALL3METHODS", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 2216, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("CDLKICKING", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 1862, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.CDLRISEFALL3METHODS", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.CDLKICKING", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(2, 2216, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(2, 2216, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(2, 2216, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(2, 2216, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_146CDLRISEFALL3METHODS(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 1864, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 1864, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 1864, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 1864, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_124CDLKICKING(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_146CDLRISEFALL3METHODS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_124CDLKICKING(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -17494,55 +19680,58 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_146CDLRISEFALL3METHODS(CYTHON_UNUSED P
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
   npy_int __pyx_t_3;
-  __Pyx_RefNannySetupContext("CDLRISEFALL3METHODS", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("CDLKICKING", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_open);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2233, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1881, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2234, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1882, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2235, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1883, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2236, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1884, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(2, 2237, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 1885, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
-  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_v_open->data), ((double *)__pyx_v_high->data), ((double *)__pyx_v_low->data), ((double *)__pyx_v_close->data)); if (unlikely(__pyx_t_3 == ((npy_int)-1))) __PYX_ERR(2, 2238, __pyx_L1_error)
+  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 1886, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_3;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLRISEFALL3METHODS_Lookback());
+  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLKICKING_Lookback());
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2241, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1889, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_CDLRISEFALL3METHODS(0, __pyx_v_endidx, (((double *)__pyx_v_open->data) + __pyx_v_begidx), (((double *)__pyx_v_high->data) + __pyx_v_begidx), (((double *)__pyx_v_low->data) + __pyx_v_begidx), (((double *)__pyx_v_close->data) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_v_outinteger->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_CDLKICKING(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLRISEFALL3METHODS, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2243, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLKICKING, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1891, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outinteger));
+  __Pyx_INCREF((PyObject *)__pyx_v_outinteger);
   __pyx_r = ((PyObject *)__pyx_v_outinteger);
   goto __pyx_L0;
 
@@ -17550,7 +19739,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_146CDLRISEFALL3METHODS(CYTHON_UNUSED P
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.CDLRISEFALL3METHODS", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.CDLKICKING", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_outinteger);
@@ -17565,99 +19754,129 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_146CDLRISEFALL3METHODS(CYTHON_UNUSED P
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_149CDLSEPARATINGLINES(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_148CDLSEPARATINGLINES[] = " CDLSEPARATINGLINES(open, high, low, close)\n\n    Separating Lines (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_149CDLSEPARATINGLINES = {"CDLSEPARATINGLINES", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_149CDLSEPARATINGLINES, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_148CDLSEPARATINGLINES};
-static PyObject *__pyx_pw_5talib_7_ta_lib_149CDLSEPARATINGLINES(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_127CDLKICKINGBYLENGTH(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_126CDLKICKINGBYLENGTH, "CDLKICKINGBYLENGTH(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLKICKINGBYLENGTH(open, high, low, close)\n\nKicking - bull/bear determined by the longer marubozu (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_127CDLKICKINGBYLENGTH = {"CDLKICKINGBYLENGTH", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_127CDLKICKINGBYLENGTH, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_126CDLKICKINGBYLENGTH};
+static PyObject *__pyx_pw_5talib_7_ta_lib_127CDLKICKINGBYLENGTH(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_open = 0;
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("CDLSEPARATINGLINES (wrapper)", 0);
+  __Pyx_RefNannySetupContext("CDLKICKINGBYLENGTH (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 1894, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1894, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1894, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1894, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1894, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLSEPARATINGLINES", 1, 4, 4, 1); __PYX_ERR(2, 2248, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLSEPARATINGLINES", 1, 4, 4, 2); __PYX_ERR(2, 2248, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLSEPARATINGLINES", 1, 4, 4, 3); __PYX_ERR(2, 2248, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "CDLSEPARATINGLINES") < 0)) __PYX_ERR(2, 2248, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLKICKINGBYLENGTH", 0) < (0)) __PYX_ERR(4, 1894, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLKICKINGBYLENGTH", 1, 4, 4, i); __PYX_ERR(4, 1894, __pyx_L3_error) }
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
+    } else if (unlikely(__pyx_nargs != 4)) {
       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[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1894, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1894, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1894, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1894, __pyx_L3_error)
     }
     __pyx_v_open = ((PyArrayObject *)values[0]);
     __pyx_v_high = ((PyArrayObject *)values[1]);
     __pyx_v_low = ((PyArrayObject *)values[2]);
     __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("CDLSEPARATINGLINES", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 2248, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("CDLKICKINGBYLENGTH", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 1894, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.CDLSEPARATINGLINES", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.CDLKICKINGBYLENGTH", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(2, 2248, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(2, 2248, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(2, 2248, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(2, 2248, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_148CDLSEPARATINGLINES(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 1896, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 1896, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 1896, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 1896, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_126CDLKICKINGBYLENGTH(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_148CDLSEPARATINGLINES(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_126CDLKICKINGBYLENGTH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -17671,55 +19890,58 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_148CDLSEPARATINGLINES(CYTHON_UNUSED Py
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
   npy_int __pyx_t_3;
-  __Pyx_RefNannySetupContext("CDLSEPARATINGLINES", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("CDLKICKINGBYLENGTH", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_open);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2265, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1913, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2266, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1914, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2267, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1915, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2268, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1916, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(2, 2269, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 1917, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
-  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_v_open->data), ((double *)__pyx_v_high->data), ((double *)__pyx_v_low->data), ((double *)__pyx_v_close->data)); if (unlikely(__pyx_t_3 == ((npy_int)-1))) __PYX_ERR(2, 2270, __pyx_L1_error)
+  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 1918, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_3;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLSEPARATINGLINES_Lookback());
+  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLKICKINGBYLENGTH_Lookback());
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2273, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1921, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_CDLSEPARATINGLINES(0, __pyx_v_endidx, (((double *)__pyx_v_open->data) + __pyx_v_begidx), (((double *)__pyx_v_high->data) + __pyx_v_begidx), (((double *)__pyx_v_low->data) + __pyx_v_begidx), (((double *)__pyx_v_close->data) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_v_outinteger->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_CDLKICKINGBYLENGTH(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLSEPARATINGLINES, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2275, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLKICKINGBYLENGTH, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1923, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outinteger));
+  __Pyx_INCREF((PyObject *)__pyx_v_outinteger);
   __pyx_r = ((PyObject *)__pyx_v_outinteger);
   goto __pyx_L0;
 
@@ -17727,7 +19949,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_148CDLSEPARATINGLINES(CYTHON_UNUSED Py
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.CDLSEPARATINGLINES", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.CDLKICKINGBYLENGTH", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_outinteger);
@@ -17742,99 +19964,129 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_148CDLSEPARATINGLINES(CYTHON_UNUSED Py
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_151CDLSHOOTINGSTAR(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_150CDLSHOOTINGSTAR[] = " CDLSHOOTINGSTAR(open, high, low, close)\n\n    Shooting Star (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_151CDLSHOOTINGSTAR = {"CDLSHOOTINGSTAR", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_151CDLSHOOTINGSTAR, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_150CDLSHOOTINGSTAR};
-static PyObject *__pyx_pw_5talib_7_ta_lib_151CDLSHOOTINGSTAR(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_129CDLLADDERBOTTOM(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_128CDLLADDERBOTTOM, "CDLLADDERBOTTOM(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLLADDERBOTTOM(open, high, low, close)\n\nLadder Bottom (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_129CDLLADDERBOTTOM = {"CDLLADDERBOTTOM", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_129CDLLADDERBOTTOM, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_128CDLLADDERBOTTOM};
+static PyObject *__pyx_pw_5talib_7_ta_lib_129CDLLADDERBOTTOM(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_open = 0;
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("CDLSHOOTINGSTAR (wrapper)", 0);
+  __Pyx_RefNannySetupContext("CDLLADDERBOTTOM (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 1926, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1926, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1926, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1926, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1926, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLSHOOTINGSTAR", 1, 4, 4, 1); __PYX_ERR(2, 2280, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLSHOOTINGSTAR", 1, 4, 4, 2); __PYX_ERR(2, 2280, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLSHOOTINGSTAR", 1, 4, 4, 3); __PYX_ERR(2, 2280, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "CDLSHOOTINGSTAR") < 0)) __PYX_ERR(2, 2280, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLLADDERBOTTOM", 0) < (0)) __PYX_ERR(4, 1926, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLLADDERBOTTOM", 1, 4, 4, i); __PYX_ERR(4, 1926, __pyx_L3_error) }
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
+    } else if (unlikely(__pyx_nargs != 4)) {
       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[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1926, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1926, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1926, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1926, __pyx_L3_error)
     }
     __pyx_v_open = ((PyArrayObject *)values[0]);
     __pyx_v_high = ((PyArrayObject *)values[1]);
     __pyx_v_low = ((PyArrayObject *)values[2]);
     __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("CDLSHOOTINGSTAR", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 2280, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("CDLLADDERBOTTOM", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 1926, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.CDLSHOOTINGSTAR", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.CDLLADDERBOTTOM", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(2, 2280, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(2, 2280, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(2, 2280, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(2, 2280, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_150CDLSHOOTINGSTAR(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 1928, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 1928, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 1928, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 1928, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_128CDLLADDERBOTTOM(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_150CDLSHOOTINGSTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_128CDLLADDERBOTTOM(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -17848,55 +20100,58 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_150CDLSHOOTINGSTAR(CYTHON_UNUSED PyObj
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
   npy_int __pyx_t_3;
-  __Pyx_RefNannySetupContext("CDLSHOOTINGSTAR", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("CDLLADDERBOTTOM", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_open);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2297, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1945, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2298, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1946, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2299, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1947, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2300, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1948, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(2, 2301, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 1949, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
-  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_v_open->data), ((double *)__pyx_v_high->data), ((double *)__pyx_v_low->data), ((double *)__pyx_v_close->data)); if (unlikely(__pyx_t_3 == ((npy_int)-1))) __PYX_ERR(2, 2302, __pyx_L1_error)
+  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 1950, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_3;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLSHOOTINGSTAR_Lookback());
+  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLLADDERBOTTOM_Lookback());
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2305, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1953, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_CDLSHOOTINGSTAR(0, __pyx_v_endidx, (((double *)__pyx_v_open->data) + __pyx_v_begidx), (((double *)__pyx_v_high->data) + __pyx_v_begidx), (((double *)__pyx_v_low->data) + __pyx_v_begidx), (((double *)__pyx_v_close->data) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_v_outinteger->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_CDLLADDERBOTTOM(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLSHOOTINGSTAR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2307, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLLADDERBOTTOM, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1955, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outinteger));
+  __Pyx_INCREF((PyObject *)__pyx_v_outinteger);
   __pyx_r = ((PyObject *)__pyx_v_outinteger);
   goto __pyx_L0;
 
@@ -17904,7 +20159,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_150CDLSHOOTINGSTAR(CYTHON_UNUSED PyObj
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.CDLSHOOTINGSTAR", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.CDLLADDERBOTTOM", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_outinteger);
@@ -17919,99 +20174,129 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_150CDLSHOOTINGSTAR(CYTHON_UNUSED PyObj
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_153CDLSHORTLINE(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_152CDLSHORTLINE[] = " CDLSHORTLINE(open, high, low, close)\n\n    Short Line Candle (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_153CDLSHORTLINE = {"CDLSHORTLINE", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_153CDLSHORTLINE, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_152CDLSHORTLINE};
-static PyObject *__pyx_pw_5talib_7_ta_lib_153CDLSHORTLINE(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_131CDLLONGLEGGEDDOJI(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_130CDLLONGLEGGEDDOJI, "CDLLONGLEGGEDDOJI(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLLONGLEGGEDDOJI(open, high, low, close)\n\nLong Legged Doji (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_131CDLLONGLEGGEDDOJI = {"CDLLONGLEGGEDDOJI", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_131CDLLONGLEGGEDDOJI, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_130CDLLONGLEGGEDDOJI};
+static PyObject *__pyx_pw_5talib_7_ta_lib_131CDLLONGLEGGEDDOJI(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_open = 0;
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("CDLSHORTLINE (wrapper)", 0);
+  __Pyx_RefNannySetupContext("CDLLONGLEGGEDDOJI (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 1958, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1958, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1958, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1958, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1958, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLSHORTLINE", 1, 4, 4, 1); __PYX_ERR(2, 2312, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLSHORTLINE", 1, 4, 4, 2); __PYX_ERR(2, 2312, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLSHORTLINE", 1, 4, 4, 3); __PYX_ERR(2, 2312, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "CDLSHORTLINE") < 0)) __PYX_ERR(2, 2312, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLLONGLEGGEDDOJI", 0) < (0)) __PYX_ERR(4, 1958, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLLONGLEGGEDDOJI", 1, 4, 4, i); __PYX_ERR(4, 1958, __pyx_L3_error) }
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
+    } else if (unlikely(__pyx_nargs != 4)) {
       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[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1958, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1958, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1958, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1958, __pyx_L3_error)
     }
     __pyx_v_open = ((PyArrayObject *)values[0]);
     __pyx_v_high = ((PyArrayObject *)values[1]);
     __pyx_v_low = ((PyArrayObject *)values[2]);
     __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("CDLSHORTLINE", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 2312, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("CDLLONGLEGGEDDOJI", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 1958, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.CDLSHORTLINE", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.CDLLONGLEGGEDDOJI", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(2, 2312, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(2, 2312, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(2, 2312, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(2, 2312, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_152CDLSHORTLINE(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 1960, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 1960, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 1960, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 1960, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_130CDLLONGLEGGEDDOJI(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_152CDLSHORTLINE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_130CDLLONGLEGGEDDOJI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -18025,55 +20310,58 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_152CDLSHORTLINE(CYTHON_UNUSED PyObject
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
   npy_int __pyx_t_3;
-  __Pyx_RefNannySetupContext("CDLSHORTLINE", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("CDLLONGLEGGEDDOJI", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_open);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2329, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1977, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2330, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1978, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2331, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1979, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2332, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1980, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(2, 2333, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 1981, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
-  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_v_open->data), ((double *)__pyx_v_high->data), ((double *)__pyx_v_low->data), ((double *)__pyx_v_close->data)); if (unlikely(__pyx_t_3 == ((npy_int)-1))) __PYX_ERR(2, 2334, __pyx_L1_error)
+  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 1982, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_3;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLSHORTLINE_Lookback());
+  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLLONGLEGGEDDOJI_Lookback());
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2337, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1985, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_CDLSHORTLINE(0, __pyx_v_endidx, (((double *)__pyx_v_open->data) + __pyx_v_begidx), (((double *)__pyx_v_high->data) + __pyx_v_begidx), (((double *)__pyx_v_low->data) + __pyx_v_begidx), (((double *)__pyx_v_close->data) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_v_outinteger->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_CDLLONGLEGGEDDOJI(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLSHORTLINE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2339, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLLONGLEGGEDDOJI, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 1987, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outinteger));
+  __Pyx_INCREF((PyObject *)__pyx_v_outinteger);
   __pyx_r = ((PyObject *)__pyx_v_outinteger);
   goto __pyx_L0;
 
@@ -18081,7 +20369,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_152CDLSHORTLINE(CYTHON_UNUSED PyObject
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.CDLSHORTLINE", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.CDLLONGLEGGEDDOJI", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_outinteger);
@@ -18096,99 +20384,129 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_152CDLSHORTLINE(CYTHON_UNUSED PyObject
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_155CDLSPINNINGTOP(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_154CDLSPINNINGTOP[] = " CDLSPINNINGTOP(open, high, low, close)\n\n    Spinning Top (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_155CDLSPINNINGTOP = {"CDLSPINNINGTOP", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_155CDLSPINNINGTOP, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_154CDLSPINNINGTOP};
-static PyObject *__pyx_pw_5talib_7_ta_lib_155CDLSPINNINGTOP(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_133CDLLONGLINE(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_132CDLLONGLINE, "CDLLONGLINE(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLLONGLINE(open, high, low, close)\n\nLong Line Candle (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_133CDLLONGLINE = {"CDLLONGLINE", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_133CDLLONGLINE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_132CDLLONGLINE};
+static PyObject *__pyx_pw_5talib_7_ta_lib_133CDLLONGLINE(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_open = 0;
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("CDLSPINNINGTOP (wrapper)", 0);
+  __Pyx_RefNannySetupContext("CDLLONGLINE (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 1990, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1990, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1990, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1990, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1990, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLSPINNINGTOP", 1, 4, 4, 1); __PYX_ERR(2, 2344, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLSPINNINGTOP", 1, 4, 4, 2); __PYX_ERR(2, 2344, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLSPINNINGTOP", 1, 4, 4, 3); __PYX_ERR(2, 2344, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "CDLSPINNINGTOP") < 0)) __PYX_ERR(2, 2344, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLLONGLINE", 0) < (0)) __PYX_ERR(4, 1990, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLLONGLINE", 1, 4, 4, i); __PYX_ERR(4, 1990, __pyx_L3_error) }
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
+    } else if (unlikely(__pyx_nargs != 4)) {
       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[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 1990, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 1990, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 1990, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 1990, __pyx_L3_error)
     }
     __pyx_v_open = ((PyArrayObject *)values[0]);
     __pyx_v_high = ((PyArrayObject *)values[1]);
     __pyx_v_low = ((PyArrayObject *)values[2]);
     __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("CDLSPINNINGTOP", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 2344, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("CDLLONGLINE", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 1990, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.CDLSPINNINGTOP", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.CDLLONGLINE", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(2, 2344, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(2, 2344, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(2, 2344, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(2, 2344, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_154CDLSPINNINGTOP(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 1992, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 1992, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 1992, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 1992, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_132CDLLONGLINE(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_154CDLSPINNINGTOP(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_132CDLLONGLINE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -18202,55 +20520,58 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_154CDLSPINNINGTOP(CYTHON_UNUSED PyObje
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
   npy_int __pyx_t_3;
-  __Pyx_RefNannySetupContext("CDLSPINNINGTOP", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("CDLLONGLINE", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_open);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2361, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2009, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2362, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2010, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2363, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2011, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2364, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2012, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(2, 2365, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 2013, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
-  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_v_open->data), ((double *)__pyx_v_high->data), ((double *)__pyx_v_low->data), ((double *)__pyx_v_close->data)); if (unlikely(__pyx_t_3 == ((npy_int)-1))) __PYX_ERR(2, 2366, __pyx_L1_error)
+  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 2014, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_3;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLSPINNINGTOP_Lookback());
+  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLLONGLINE_Lookback());
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2369, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2017, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_CDLSPINNINGTOP(0, __pyx_v_endidx, (((double *)__pyx_v_open->data) + __pyx_v_begidx), (((double *)__pyx_v_high->data) + __pyx_v_begidx), (((double *)__pyx_v_low->data) + __pyx_v_begidx), (((double *)__pyx_v_close->data) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_v_outinteger->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_CDLLONGLINE(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLSPINNINGTOP, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2371, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLLONGLINE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2019, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outinteger));
+  __Pyx_INCREF((PyObject *)__pyx_v_outinteger);
   __pyx_r = ((PyObject *)__pyx_v_outinteger);
   goto __pyx_L0;
 
@@ -18258,7 +20579,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_154CDLSPINNINGTOP(CYTHON_UNUSED PyObje
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.CDLSPINNINGTOP", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.CDLLONGLINE", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_outinteger);
@@ -18273,99 +20594,129 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_154CDLSPINNINGTOP(CYTHON_UNUSED PyObje
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_157CDLSTALLEDPATTERN(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_156CDLSTALLEDPATTERN[] = " CDLSTALLEDPATTERN(open, high, low, close)\n\n    Stalled Pattern (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_157CDLSTALLEDPATTERN = {"CDLSTALLEDPATTERN", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_157CDLSTALLEDPATTERN, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_156CDLSTALLEDPATTERN};
-static PyObject *__pyx_pw_5talib_7_ta_lib_157CDLSTALLEDPATTERN(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_135CDLMARUBOZU(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_134CDLMARUBOZU, "CDLMARUBOZU(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLMARUBOZU(open, high, low, close)\n\nMarubozu (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_135CDLMARUBOZU = {"CDLMARUBOZU", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_135CDLMARUBOZU, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_134CDLMARUBOZU};
+static PyObject *__pyx_pw_5talib_7_ta_lib_135CDLMARUBOZU(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_open = 0;
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("CDLSTALLEDPATTERN (wrapper)", 0);
+  __Pyx_RefNannySetupContext("CDLMARUBOZU (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 2022, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 2022, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 2022, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2022, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2022, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLSTALLEDPATTERN", 1, 4, 4, 1); __PYX_ERR(2, 2376, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLSTALLEDPATTERN", 1, 4, 4, 2); __PYX_ERR(2, 2376, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLSTALLEDPATTERN", 1, 4, 4, 3); __PYX_ERR(2, 2376, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "CDLSTALLEDPATTERN") < 0)) __PYX_ERR(2, 2376, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLMARUBOZU", 0) < (0)) __PYX_ERR(4, 2022, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLMARUBOZU", 1, 4, 4, i); __PYX_ERR(4, 2022, __pyx_L3_error) }
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
+    } else if (unlikely(__pyx_nargs != 4)) {
       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[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2022, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2022, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 2022, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 2022, __pyx_L3_error)
     }
     __pyx_v_open = ((PyArrayObject *)values[0]);
     __pyx_v_high = ((PyArrayObject *)values[1]);
     __pyx_v_low = ((PyArrayObject *)values[2]);
     __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("CDLSTALLEDPATTERN", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 2376, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("CDLMARUBOZU", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 2022, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.CDLSTALLEDPATTERN", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.CDLMARUBOZU", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(2, 2376, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(2, 2376, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(2, 2376, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(2, 2376, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_156CDLSTALLEDPATTERN(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 2024, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 2024, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 2024, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 2024, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_134CDLMARUBOZU(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_156CDLSTALLEDPATTERN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_134CDLMARUBOZU(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -18379,55 +20730,58 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_156CDLSTALLEDPATTERN(CYTHON_UNUSED PyO
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
   npy_int __pyx_t_3;
-  __Pyx_RefNannySetupContext("CDLSTALLEDPATTERN", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("CDLMARUBOZU", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_open);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2393, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2041, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2394, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2042, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2395, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2043, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2396, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2044, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(2, 2397, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 2045, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
-  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_v_open->data), ((double *)__pyx_v_high->data), ((double *)__pyx_v_low->data), ((double *)__pyx_v_close->data)); if (unlikely(__pyx_t_3 == ((npy_int)-1))) __PYX_ERR(2, 2398, __pyx_L1_error)
+  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 2046, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_3;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLSTALLEDPATTERN_Lookback());
+  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLMARUBOZU_Lookback());
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2401, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2049, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_CDLSTALLEDPATTERN(0, __pyx_v_endidx, (((double *)__pyx_v_open->data) + __pyx_v_begidx), (((double *)__pyx_v_high->data) + __pyx_v_begidx), (((double *)__pyx_v_low->data) + __pyx_v_begidx), (((double *)__pyx_v_close->data) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_v_outinteger->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_CDLMARUBOZU(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLSTALLEDPATTERN, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2403, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLMARUBOZU, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2051, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outinteger));
+  __Pyx_INCREF((PyObject *)__pyx_v_outinteger);
   __pyx_r = ((PyObject *)__pyx_v_outinteger);
   goto __pyx_L0;
 
@@ -18435,7 +20789,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_156CDLSTALLEDPATTERN(CYTHON_UNUSED PyO
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.CDLSTALLEDPATTERN", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.CDLMARUBOZU", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_outinteger);
@@ -18450,99 +20804,129 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_156CDLSTALLEDPATTERN(CYTHON_UNUSED PyO
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_159CDLSTICKSANDWICH(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_158CDLSTICKSANDWICH[] = " CDLSTICKSANDWICH(open, high, low, close)\n\n    Stick Sandwich (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_159CDLSTICKSANDWICH = {"CDLSTICKSANDWICH", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_159CDLSTICKSANDWICH, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_158CDLSTICKSANDWICH};
-static PyObject *__pyx_pw_5talib_7_ta_lib_159CDLSTICKSANDWICH(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_137CDLMATCHINGLOW(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_136CDLMATCHINGLOW, "CDLMATCHINGLOW(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLMATCHINGLOW(open, high, low, close)\n\nMatching Low (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_137CDLMATCHINGLOW = {"CDLMATCHINGLOW", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_137CDLMATCHINGLOW, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_136CDLMATCHINGLOW};
+static PyObject *__pyx_pw_5talib_7_ta_lib_137CDLMATCHINGLOW(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_open = 0;
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("CDLSTICKSANDWICH (wrapper)", 0);
+  __Pyx_RefNannySetupContext("CDLMATCHINGLOW (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 2054, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 2054, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 2054, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2054, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2054, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLSTICKSANDWICH", 1, 4, 4, 1); __PYX_ERR(2, 2408, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLSTICKSANDWICH", 1, 4, 4, 2); __PYX_ERR(2, 2408, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLSTICKSANDWICH", 1, 4, 4, 3); __PYX_ERR(2, 2408, __pyx_L3_error)
-        }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLMATCHINGLOW", 0) < (0)) __PYX_ERR(4, 2054, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLMATCHINGLOW", 1, 4, 4, i); __PYX_ERR(4, 2054, __pyx_L3_error) }
       }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "CDLSTICKSANDWICH") < 0)) __PYX_ERR(2, 2408, __pyx_L3_error)
-      }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
+    } else if (unlikely(__pyx_nargs != 4)) {
       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[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2054, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2054, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 2054, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 2054, __pyx_L3_error)
     }
     __pyx_v_open = ((PyArrayObject *)values[0]);
     __pyx_v_high = ((PyArrayObject *)values[1]);
     __pyx_v_low = ((PyArrayObject *)values[2]);
     __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("CDLSTICKSANDWICH", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 2408, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("CDLMATCHINGLOW", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 2054, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.CDLSTICKSANDWICH", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.CDLMATCHINGLOW", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(2, 2408, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(2, 2408, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(2, 2408, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(2, 2408, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_158CDLSTICKSANDWICH(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 2056, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 2056, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 2056, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 2056, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_136CDLMATCHINGLOW(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_158CDLSTICKSANDWICH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_136CDLMATCHINGLOW(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -18556,55 +20940,58 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_158CDLSTICKSANDWICH(CYTHON_UNUSED PyOb
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
   npy_int __pyx_t_3;
-  __Pyx_RefNannySetupContext("CDLSTICKSANDWICH", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("CDLMATCHINGLOW", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_open);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2425, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2073, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2426, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2074, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2427, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2075, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2428, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2076, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(2, 2429, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 2077, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
-  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_v_open->data), ((double *)__pyx_v_high->data), ((double *)__pyx_v_low->data), ((double *)__pyx_v_close->data)); if (unlikely(__pyx_t_3 == ((npy_int)-1))) __PYX_ERR(2, 2430, __pyx_L1_error)
+  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 2078, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_3;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLSTICKSANDWICH_Lookback());
+  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLMATCHINGLOW_Lookback());
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2433, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2081, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_CDLSTICKSANDWICH(0, __pyx_v_endidx, (((double *)__pyx_v_open->data) + __pyx_v_begidx), (((double *)__pyx_v_high->data) + __pyx_v_begidx), (((double *)__pyx_v_low->data) + __pyx_v_begidx), (((double *)__pyx_v_close->data) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_v_outinteger->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_CDLMATCHINGLOW(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLSTICKSANDWICH, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2435, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLMATCHINGLOW, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2083, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outinteger));
+  __Pyx_INCREF((PyObject *)__pyx_v_outinteger);
   __pyx_r = ((PyObject *)__pyx_v_outinteger);
   goto __pyx_L0;
 
@@ -18612,7 +20999,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_158CDLSTICKSANDWICH(CYTHON_UNUSED PyOb
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.CDLSTICKSANDWICH", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.CDLMATCHINGLOW", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_outinteger);
@@ -18627,99 +21014,146 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_158CDLSTICKSANDWICH(CYTHON_UNUSED PyOb
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_161CDLTAKURI(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_160CDLTAKURI[] = " CDLTAKURI(open, high, low, close)\n\n    Takuri (Dragonfly Doji with very long lower shadow) (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_161CDLTAKURI = {"CDLTAKURI", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_161CDLTAKURI, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_160CDLTAKURI};
-static PyObject *__pyx_pw_5talib_7_ta_lib_161CDLTAKURI(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_139CDLMATHOLD(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_138CDLMATHOLD, "CDLMATHOLD(ndarray open, ndarray high, ndarray low, ndarray close, double penetration=0.5)\n\nCDLMATHOLD(open, high, low, close[, penetration=?])\n\nMat Hold (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nParameters:\n    penetration: 0.5\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_139CDLMATHOLD = {"CDLMATHOLD", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_139CDLMATHOLD, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_138CDLMATHOLD};
+static PyObject *__pyx_pw_5talib_7_ta_lib_139CDLMATHOLD(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_open = 0;
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
+  double __pyx_v_penetration;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[5] = {0,0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("CDLTAKURI (wrapper)", 0);
+  __Pyx_RefNannySetupContext("CDLMATHOLD (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,&__pyx_mstate_global->__pyx_n_u_penetration,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 2086, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  5:
+        values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(4, 2086, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 2086, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 2086, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  0: break;
-        default: goto __pyx_L5_argtuple_error;
-      }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2086, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLTAKURI", 1, 4, 4, 1); __PYX_ERR(2, 2440, __pyx_L3_error)
-        }
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2086, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLTAKURI", 1, 4, 4, 2); __PYX_ERR(2, 2440, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLTAKURI", 1, 4, 4, 3); __PYX_ERR(2, 2440, __pyx_L3_error)
-        }
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
       }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "CDLTAKURI") < 0)) __PYX_ERR(2, 2440, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLMATHOLD", 0) < (0)) __PYX_ERR(4, 2086, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLMATHOLD", 0, 4, 5, i); __PYX_ERR(4, 2086, __pyx_L3_error) }
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
-      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);
+      switch (__pyx_nargs) {
+        case  5:
+        values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(4, 2086, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 2086, __pyx_L3_error)
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 2086, __pyx_L3_error)
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2086, __pyx_L3_error)
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2086, __pyx_L3_error)
+        break;
+        default: goto __pyx_L5_argtuple_error;
+      }
     }
     __pyx_v_open = ((PyArrayObject *)values[0]);
     __pyx_v_high = ((PyArrayObject *)values[1]);
     __pyx_v_low = ((PyArrayObject *)values[2]);
     __pyx_v_close = ((PyArrayObject *)values[3]);
+    if (values[4]) {
+      __pyx_v_penetration = __Pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_penetration == (double)-1) && PyErr_Occurred())) __PYX_ERR(4, 2088, __pyx_L3_error)
+    } else {
+      __pyx_v_penetration = ((double)((double)0.5));
+    }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("CDLTAKURI", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 2440, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("CDLMATHOLD", 0, 4, 5, __pyx_nargs); __PYX_ERR(4, 2086, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.CDLTAKURI", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.CDLMATHOLD", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(2, 2440, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(2, 2440, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(2, 2440, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(2, 2440, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_160CDLTAKURI(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 2088, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 2088, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 2088, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 2088, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_138CDLMATHOLD(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_penetration);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_160CDLTAKURI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_138CDLMATHOLD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -18733,55 +21167,58 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_160CDLTAKURI(CYTHON_UNUSED PyObject *_
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
   npy_int __pyx_t_3;
-  __Pyx_RefNannySetupContext("CDLTAKURI", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("CDLMATHOLD", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_open);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2457, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2107, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2458, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2108, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2459, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2109, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2460, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2110, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(2, 2461, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 2111, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
-  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_v_open->data), ((double *)__pyx_v_high->data), ((double *)__pyx_v_low->data), ((double *)__pyx_v_close->data)); if (unlikely(__pyx_t_3 == ((npy_int)-1))) __PYX_ERR(2, 2462, __pyx_L1_error)
+  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 2112, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_3;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLTAKURI_Lookback());
+  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLMATHOLD_Lookback(__pyx_v_penetration));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2465, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2115, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_CDLTAKURI(0, __pyx_v_endidx, (((double *)__pyx_v_open->data) + __pyx_v_begidx), (((double *)__pyx_v_high->data) + __pyx_v_begidx), (((double *)__pyx_v_low->data) + __pyx_v_begidx), (((double *)__pyx_v_close->data) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_v_outinteger->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_CDLMATHOLD(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), __pyx_v_penetration, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLTAKURI, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2467, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLMATHOLD, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2117, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outinteger));
+  __Pyx_INCREF((PyObject *)__pyx_v_outinteger);
   __pyx_r = ((PyObject *)__pyx_v_outinteger);
   goto __pyx_L0;
 
@@ -18789,7 +21226,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_160CDLTAKURI(CYTHON_UNUSED PyObject *_
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.CDLTAKURI", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.CDLMATHOLD", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_outinteger);
@@ -18804,99 +21241,146 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_160CDLTAKURI(CYTHON_UNUSED PyObject *_
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_163CDLTASUKIGAP(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_162CDLTASUKIGAP[] = " CDLTASUKIGAP(open, high, low, close)\n\n    Tasuki Gap (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_163CDLTASUKIGAP = {"CDLTASUKIGAP", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_163CDLTASUKIGAP, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_162CDLTASUKIGAP};
-static PyObject *__pyx_pw_5talib_7_ta_lib_163CDLTASUKIGAP(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_141CDLMORNINGDOJISTAR(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_140CDLMORNINGDOJISTAR, "CDLMORNINGDOJISTAR(ndarray open, ndarray high, ndarray low, ndarray close, double penetration=0.3)\n\nCDLMORNINGDOJISTAR(open, high, low, close[, penetration=?])\n\nMorning Doji Star (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nParameters:\n    penetration: 0.3\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_141CDLMORNINGDOJISTAR = {"CDLMORNINGDOJISTAR", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_141CDLMORNINGDOJISTAR, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_140CDLMORNINGDOJISTAR};
+static PyObject *__pyx_pw_5talib_7_ta_lib_141CDLMORNINGDOJISTAR(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_open = 0;
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
+  double __pyx_v_penetration;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[5] = {0,0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("CDLTASUKIGAP (wrapper)", 0);
+  __Pyx_RefNannySetupContext("CDLMORNINGDOJISTAR (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,&__pyx_mstate_global->__pyx_n_u_penetration,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 2120, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  5:
+        values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(4, 2120, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 2120, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 2120, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  0: break;
-        default: goto __pyx_L5_argtuple_error;
-      }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2120, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLTASUKIGAP", 1, 4, 4, 1); __PYX_ERR(2, 2472, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLTASUKIGAP", 1, 4, 4, 2); __PYX_ERR(2, 2472, __pyx_L3_error)
-        }
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2120, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLTASUKIGAP", 1, 4, 4, 3); __PYX_ERR(2, 2472, __pyx_L3_error)
-        }
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
       }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "CDLTASUKIGAP") < 0)) __PYX_ERR(2, 2472, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLMORNINGDOJISTAR", 0) < (0)) __PYX_ERR(4, 2120, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLMORNINGDOJISTAR", 0, 4, 5, i); __PYX_ERR(4, 2120, __pyx_L3_error) }
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
-      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);
+      switch (__pyx_nargs) {
+        case  5:
+        values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(4, 2120, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 2120, __pyx_L3_error)
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 2120, __pyx_L3_error)
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2120, __pyx_L3_error)
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2120, __pyx_L3_error)
+        break;
+        default: goto __pyx_L5_argtuple_error;
+      }
     }
     __pyx_v_open = ((PyArrayObject *)values[0]);
     __pyx_v_high = ((PyArrayObject *)values[1]);
     __pyx_v_low = ((PyArrayObject *)values[2]);
     __pyx_v_close = ((PyArrayObject *)values[3]);
+    if (values[4]) {
+      __pyx_v_penetration = __Pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_penetration == (double)-1) && PyErr_Occurred())) __PYX_ERR(4, 2122, __pyx_L3_error)
+    } else {
+      __pyx_v_penetration = ((double)((double)0.3));
+    }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("CDLTASUKIGAP", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 2472, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("CDLMORNINGDOJISTAR", 0, 4, 5, __pyx_nargs); __PYX_ERR(4, 2120, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.CDLTASUKIGAP", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.CDLMORNINGDOJISTAR", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(2, 2472, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(2, 2472, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(2, 2472, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(2, 2472, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_162CDLTASUKIGAP(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 2122, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 2122, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 2122, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 2122, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_140CDLMORNINGDOJISTAR(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_penetration);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_162CDLTASUKIGAP(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_140CDLMORNINGDOJISTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -18910,55 +21394,58 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_162CDLTASUKIGAP(CYTHON_UNUSED PyObject
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
   npy_int __pyx_t_3;
-  __Pyx_RefNannySetupContext("CDLTASUKIGAP", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("CDLMORNINGDOJISTAR", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_open);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2489, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2141, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2490, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2142, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2491, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2143, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2492, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2144, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(2, 2493, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 2145, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
-  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_v_open->data), ((double *)__pyx_v_high->data), ((double *)__pyx_v_low->data), ((double *)__pyx_v_close->data)); if (unlikely(__pyx_t_3 == ((npy_int)-1))) __PYX_ERR(2, 2494, __pyx_L1_error)
+  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 2146, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_3;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLTASUKIGAP_Lookback());
+  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLMORNINGDOJISTAR_Lookback(__pyx_v_penetration));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2497, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2149, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_CDLTASUKIGAP(0, __pyx_v_endidx, (((double *)__pyx_v_open->data) + __pyx_v_begidx), (((double *)__pyx_v_high->data) + __pyx_v_begidx), (((double *)__pyx_v_low->data) + __pyx_v_begidx), (((double *)__pyx_v_close->data) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_v_outinteger->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_CDLMORNINGDOJISTAR(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), __pyx_v_penetration, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLTASUKIGAP, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2499, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLMORNINGDOJISTAR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2151, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outinteger));
+  __Pyx_INCREF((PyObject *)__pyx_v_outinteger);
   __pyx_r = ((PyObject *)__pyx_v_outinteger);
   goto __pyx_L0;
 
@@ -18966,7 +21453,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_162CDLTASUKIGAP(CYTHON_UNUSED PyObject
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.CDLTASUKIGAP", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.CDLMORNINGDOJISTAR", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_outinteger);
@@ -18981,99 +21468,146 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_162CDLTASUKIGAP(CYTHON_UNUSED PyObject
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_165CDLTHRUSTING(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_164CDLTHRUSTING[] = " CDLTHRUSTING(open, high, low, close)\n\n    Thrusting Pattern (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_165CDLTHRUSTING = {"CDLTHRUSTING", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_165CDLTHRUSTING, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_164CDLTHRUSTING};
-static PyObject *__pyx_pw_5talib_7_ta_lib_165CDLTHRUSTING(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_143CDLMORNINGSTAR(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_142CDLMORNINGSTAR, "CDLMORNINGSTAR(ndarray open, ndarray high, ndarray low, ndarray close, double penetration=0.3)\n\nCDLMORNINGSTAR(open, high, low, close[, penetration=?])\n\nMorning Star (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nParameters:\n    penetration: 0.3\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_143CDLMORNINGSTAR = {"CDLMORNINGSTAR", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_143CDLMORNINGSTAR, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_142CDLMORNINGSTAR};
+static PyObject *__pyx_pw_5talib_7_ta_lib_143CDLMORNINGSTAR(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_open = 0;
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
+  double __pyx_v_penetration;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[5] = {0,0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("CDLTHRUSTING (wrapper)", 0);
+  __Pyx_RefNannySetupContext("CDLMORNINGSTAR (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,&__pyx_mstate_global->__pyx_n_u_penetration,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 2154, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  5:
+        values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(4, 2154, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 2154, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 2154, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  0: break;
-        default: goto __pyx_L5_argtuple_error;
-      }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2154, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLTHRUSTING", 1, 4, 4, 1); __PYX_ERR(2, 2504, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLTHRUSTING", 1, 4, 4, 2); __PYX_ERR(2, 2504, __pyx_L3_error)
-        }
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2154, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLTHRUSTING", 1, 4, 4, 3); __PYX_ERR(2, 2504, __pyx_L3_error)
-        }
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
       }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "CDLTHRUSTING") < 0)) __PYX_ERR(2, 2504, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLMORNINGSTAR", 0) < (0)) __PYX_ERR(4, 2154, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLMORNINGSTAR", 0, 4, 5, i); __PYX_ERR(4, 2154, __pyx_L3_error) }
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
-      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);
+      switch (__pyx_nargs) {
+        case  5:
+        values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(4, 2154, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 2154, __pyx_L3_error)
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 2154, __pyx_L3_error)
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2154, __pyx_L3_error)
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2154, __pyx_L3_error)
+        break;
+        default: goto __pyx_L5_argtuple_error;
+      }
     }
     __pyx_v_open = ((PyArrayObject *)values[0]);
     __pyx_v_high = ((PyArrayObject *)values[1]);
     __pyx_v_low = ((PyArrayObject *)values[2]);
     __pyx_v_close = ((PyArrayObject *)values[3]);
+    if (values[4]) {
+      __pyx_v_penetration = __Pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_penetration == (double)-1) && PyErr_Occurred())) __PYX_ERR(4, 2156, __pyx_L3_error)
+    } else {
+      __pyx_v_penetration = ((double)((double)0.3));
+    }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("CDLTHRUSTING", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 2504, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("CDLMORNINGSTAR", 0, 4, 5, __pyx_nargs); __PYX_ERR(4, 2154, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.CDLTHRUSTING", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.CDLMORNINGSTAR", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(2, 2504, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(2, 2504, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(2, 2504, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(2, 2504, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_164CDLTHRUSTING(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 2156, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 2156, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 2156, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 2156, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_142CDLMORNINGSTAR(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_penetration);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_164CDLTHRUSTING(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_142CDLMORNINGSTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -19087,55 +21621,58 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_164CDLTHRUSTING(CYTHON_UNUSED PyObject
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
   npy_int __pyx_t_3;
-  __Pyx_RefNannySetupContext("CDLTHRUSTING", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("CDLMORNINGSTAR", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_open);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2521, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2175, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2522, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2176, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2523, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2177, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2524, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2178, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(2, 2525, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 2179, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
-  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_v_open->data), ((double *)__pyx_v_high->data), ((double *)__pyx_v_low->data), ((double *)__pyx_v_close->data)); if (unlikely(__pyx_t_3 == ((npy_int)-1))) __PYX_ERR(2, 2526, __pyx_L1_error)
+  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 2180, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_3;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLTHRUSTING_Lookback());
+  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLMORNINGSTAR_Lookback(__pyx_v_penetration));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2529, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2183, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_CDLTHRUSTING(0, __pyx_v_endidx, (((double *)__pyx_v_open->data) + __pyx_v_begidx), (((double *)__pyx_v_high->data) + __pyx_v_begidx), (((double *)__pyx_v_low->data) + __pyx_v_begidx), (((double *)__pyx_v_close->data) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_v_outinteger->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_CDLMORNINGSTAR(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), __pyx_v_penetration, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLTHRUSTING, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2531, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLMORNINGSTAR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2185, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outinteger));
+  __Pyx_INCREF((PyObject *)__pyx_v_outinteger);
   __pyx_r = ((PyObject *)__pyx_v_outinteger);
   goto __pyx_L0;
 
@@ -19143,7 +21680,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_164CDLTHRUSTING(CYTHON_UNUSED PyObject
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.CDLTHRUSTING", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.CDLMORNINGSTAR", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_outinteger);
@@ -19158,99 +21695,129 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_164CDLTHRUSTING(CYTHON_UNUSED PyObject
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_167CDLTRISTAR(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_166CDLTRISTAR[] = " CDLTRISTAR(open, high, low, close)\n\n    Tristar Pattern (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_167CDLTRISTAR = {"CDLTRISTAR", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_167CDLTRISTAR, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_166CDLTRISTAR};
-static PyObject *__pyx_pw_5talib_7_ta_lib_167CDLTRISTAR(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_145CDLONNECK(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_144CDLONNECK, "CDLONNECK(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLONNECK(open, high, low, close)\n\nOn-Neck Pattern (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_145CDLONNECK = {"CDLONNECK", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_145CDLONNECK, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_144CDLONNECK};
+static PyObject *__pyx_pw_5talib_7_ta_lib_145CDLONNECK(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_open = 0;
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("CDLTRISTAR (wrapper)", 0);
+  __Pyx_RefNannySetupContext("CDLONNECK (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 2188, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 2188, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 2188, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2188, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2188, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLTRISTAR", 1, 4, 4, 1); __PYX_ERR(2, 2536, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLTRISTAR", 1, 4, 4, 2); __PYX_ERR(2, 2536, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLTRISTAR", 1, 4, 4, 3); __PYX_ERR(2, 2536, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "CDLTRISTAR") < 0)) __PYX_ERR(2, 2536, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLONNECK", 0) < (0)) __PYX_ERR(4, 2188, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLONNECK", 1, 4, 4, i); __PYX_ERR(4, 2188, __pyx_L3_error) }
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
+    } else if (unlikely(__pyx_nargs != 4)) {
       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[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2188, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2188, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 2188, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 2188, __pyx_L3_error)
     }
     __pyx_v_open = ((PyArrayObject *)values[0]);
     __pyx_v_high = ((PyArrayObject *)values[1]);
     __pyx_v_low = ((PyArrayObject *)values[2]);
     __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("CDLTRISTAR", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 2536, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("CDLONNECK", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 2188, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.CDLTRISTAR", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.CDLONNECK", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(2, 2536, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(2, 2536, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(2, 2536, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(2, 2536, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_166CDLTRISTAR(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 2190, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 2190, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 2190, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 2190, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_144CDLONNECK(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_166CDLTRISTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_144CDLONNECK(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -19264,55 +21831,58 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_166CDLTRISTAR(CYTHON_UNUSED PyObject *
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
   npy_int __pyx_t_3;
-  __Pyx_RefNannySetupContext("CDLTRISTAR", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("CDLONNECK", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_open);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2553, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2207, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2554, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2208, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2555, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2209, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2556, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2210, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(2, 2557, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 2211, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
-  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_v_open->data), ((double *)__pyx_v_high->data), ((double *)__pyx_v_low->data), ((double *)__pyx_v_close->data)); if (unlikely(__pyx_t_3 == ((npy_int)-1))) __PYX_ERR(2, 2558, __pyx_L1_error)
+  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 2212, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_3;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLTRISTAR_Lookback());
+  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLONNECK_Lookback());
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2561, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2215, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_CDLTRISTAR(0, __pyx_v_endidx, (((double *)__pyx_v_open->data) + __pyx_v_begidx), (((double *)__pyx_v_high->data) + __pyx_v_begidx), (((double *)__pyx_v_low->data) + __pyx_v_begidx), (((double *)__pyx_v_close->data) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_v_outinteger->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_CDLONNECK(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLTRISTAR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2563, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLONNECK, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2217, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outinteger));
+  __Pyx_INCREF((PyObject *)__pyx_v_outinteger);
   __pyx_r = ((PyObject *)__pyx_v_outinteger);
   goto __pyx_L0;
 
@@ -19320,7 +21890,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_166CDLTRISTAR(CYTHON_UNUSED PyObject *
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.CDLTRISTAR", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.CDLONNECK", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_outinteger);
@@ -19335,99 +21905,129 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_166CDLTRISTAR(CYTHON_UNUSED PyObject *
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_169CDLUNIQUE3RIVER(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_168CDLUNIQUE3RIVER[] = " CDLUNIQUE3RIVER(open, high, low, close)\n\n    Unique 3 River (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_169CDLUNIQUE3RIVER = {"CDLUNIQUE3RIVER", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_169CDLUNIQUE3RIVER, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_168CDLUNIQUE3RIVER};
-static PyObject *__pyx_pw_5talib_7_ta_lib_169CDLUNIQUE3RIVER(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_147CDLPIERCING(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_146CDLPIERCING, "CDLPIERCING(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLPIERCING(open, high, low, close)\n\nPiercing Pattern (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_147CDLPIERCING = {"CDLPIERCING", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_147CDLPIERCING, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_146CDLPIERCING};
+static PyObject *__pyx_pw_5talib_7_ta_lib_147CDLPIERCING(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_open = 0;
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("CDLUNIQUE3RIVER (wrapper)", 0);
+  __Pyx_RefNannySetupContext("CDLPIERCING (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 2220, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 2220, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 2220, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2220, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2220, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLUNIQUE3RIVER", 1, 4, 4, 1); __PYX_ERR(2, 2568, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLUNIQUE3RIVER", 1, 4, 4, 2); __PYX_ERR(2, 2568, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLUNIQUE3RIVER", 1, 4, 4, 3); __PYX_ERR(2, 2568, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "CDLUNIQUE3RIVER") < 0)) __PYX_ERR(2, 2568, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLPIERCING", 0) < (0)) __PYX_ERR(4, 2220, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLPIERCING", 1, 4, 4, i); __PYX_ERR(4, 2220, __pyx_L3_error) }
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
+    } else if (unlikely(__pyx_nargs != 4)) {
       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[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2220, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2220, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 2220, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 2220, __pyx_L3_error)
     }
     __pyx_v_open = ((PyArrayObject *)values[0]);
     __pyx_v_high = ((PyArrayObject *)values[1]);
     __pyx_v_low = ((PyArrayObject *)values[2]);
     __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("CDLUNIQUE3RIVER", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 2568, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("CDLPIERCING", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 2220, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.CDLUNIQUE3RIVER", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.CDLPIERCING", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(2, 2568, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(2, 2568, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(2, 2568, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(2, 2568, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_168CDLUNIQUE3RIVER(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 2222, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 2222, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 2222, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 2222, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_146CDLPIERCING(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_168CDLUNIQUE3RIVER(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_146CDLPIERCING(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -19441,55 +22041,58 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_168CDLUNIQUE3RIVER(CYTHON_UNUSED PyObj
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
   npy_int __pyx_t_3;
-  __Pyx_RefNannySetupContext("CDLUNIQUE3RIVER", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("CDLPIERCING", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_open);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2585, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2239, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2586, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2240, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2587, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2241, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2588, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2242, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(2, 2589, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 2243, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
-  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_v_open->data), ((double *)__pyx_v_high->data), ((double *)__pyx_v_low->data), ((double *)__pyx_v_close->data)); if (unlikely(__pyx_t_3 == ((npy_int)-1))) __PYX_ERR(2, 2590, __pyx_L1_error)
+  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 2244, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_3;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLUNIQUE3RIVER_Lookback());
+  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLPIERCING_Lookback());
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2593, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2247, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_CDLUNIQUE3RIVER(0, __pyx_v_endidx, (((double *)__pyx_v_open->data) + __pyx_v_begidx), (((double *)__pyx_v_high->data) + __pyx_v_begidx), (((double *)__pyx_v_low->data) + __pyx_v_begidx), (((double *)__pyx_v_close->data) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_v_outinteger->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_CDLPIERCING(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLUNIQUE3RIVER, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2595, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLPIERCING, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2249, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outinteger));
+  __Pyx_INCREF((PyObject *)__pyx_v_outinteger);
   __pyx_r = ((PyObject *)__pyx_v_outinteger);
   goto __pyx_L0;
 
@@ -19497,7 +22100,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_168CDLUNIQUE3RIVER(CYTHON_UNUSED PyObj
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.CDLUNIQUE3RIVER", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.CDLPIERCING", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_outinteger);
@@ -19512,99 +22115,129 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_168CDLUNIQUE3RIVER(CYTHON_UNUSED PyObj
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_171CDLUPSIDEGAP2CROWS(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_170CDLUPSIDEGAP2CROWS[] = " CDLUPSIDEGAP2CROWS(open, high, low, close)\n\n    Upside Gap Two Crows (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_171CDLUPSIDEGAP2CROWS = {"CDLUPSIDEGAP2CROWS", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_171CDLUPSIDEGAP2CROWS, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_170CDLUPSIDEGAP2CROWS};
-static PyObject *__pyx_pw_5talib_7_ta_lib_171CDLUPSIDEGAP2CROWS(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_149CDLRICKSHAWMAN(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_148CDLRICKSHAWMAN, "CDLRICKSHAWMAN(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLRICKSHAWMAN(open, high, low, close)\n\nRickshaw Man (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_149CDLRICKSHAWMAN = {"CDLRICKSHAWMAN", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_149CDLRICKSHAWMAN, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_148CDLRICKSHAWMAN};
+static PyObject *__pyx_pw_5talib_7_ta_lib_149CDLRICKSHAWMAN(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_open = 0;
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("CDLUPSIDEGAP2CROWS (wrapper)", 0);
+  __Pyx_RefNannySetupContext("CDLRICKSHAWMAN (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 2252, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 2252, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 2252, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2252, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2252, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLUPSIDEGAP2CROWS", 1, 4, 4, 1); __PYX_ERR(2, 2600, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLUPSIDEGAP2CROWS", 1, 4, 4, 2); __PYX_ERR(2, 2600, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLUPSIDEGAP2CROWS", 1, 4, 4, 3); __PYX_ERR(2, 2600, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "CDLUPSIDEGAP2CROWS") < 0)) __PYX_ERR(2, 2600, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLRICKSHAWMAN", 0) < (0)) __PYX_ERR(4, 2252, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLRICKSHAWMAN", 1, 4, 4, i); __PYX_ERR(4, 2252, __pyx_L3_error) }
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
+    } else if (unlikely(__pyx_nargs != 4)) {
       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[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2252, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2252, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 2252, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 2252, __pyx_L3_error)
     }
     __pyx_v_open = ((PyArrayObject *)values[0]);
     __pyx_v_high = ((PyArrayObject *)values[1]);
     __pyx_v_low = ((PyArrayObject *)values[2]);
     __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("CDLUPSIDEGAP2CROWS", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 2600, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("CDLRICKSHAWMAN", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 2252, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.CDLUPSIDEGAP2CROWS", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.CDLRICKSHAWMAN", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(2, 2600, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(2, 2600, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(2, 2600, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(2, 2600, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_170CDLUPSIDEGAP2CROWS(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 2254, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 2254, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 2254, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 2254, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_148CDLRICKSHAWMAN(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_170CDLUPSIDEGAP2CROWS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_148CDLRICKSHAWMAN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -19618,55 +22251,58 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_170CDLUPSIDEGAP2CROWS(CYTHON_UNUSED Py
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
   npy_int __pyx_t_3;
-  __Pyx_RefNannySetupContext("CDLUPSIDEGAP2CROWS", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("CDLRICKSHAWMAN", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_open);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2617, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2271, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2618, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2272, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2619, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2273, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2620, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2274, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(2, 2621, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 2275, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
-  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_v_open->data), ((double *)__pyx_v_high->data), ((double *)__pyx_v_low->data), ((double *)__pyx_v_close->data)); if (unlikely(__pyx_t_3 == ((npy_int)-1))) __PYX_ERR(2, 2622, __pyx_L1_error)
+  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 2276, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_3;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLUPSIDEGAP2CROWS_Lookback());
+  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLRICKSHAWMAN_Lookback());
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2625, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2279, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_CDLUPSIDEGAP2CROWS(0, __pyx_v_endidx, (((double *)__pyx_v_open->data) + __pyx_v_begidx), (((double *)__pyx_v_high->data) + __pyx_v_begidx), (((double *)__pyx_v_low->data) + __pyx_v_begidx), (((double *)__pyx_v_close->data) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_v_outinteger->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_CDLRICKSHAWMAN(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLUPSIDEGAP2CROWS, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2627, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLRICKSHAWMAN, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2281, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outinteger));
+  __Pyx_INCREF((PyObject *)__pyx_v_outinteger);
   __pyx_r = ((PyObject *)__pyx_v_outinteger);
   goto __pyx_L0;
 
@@ -19674,7 +22310,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_170CDLUPSIDEGAP2CROWS(CYTHON_UNUSED Py
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.CDLUPSIDEGAP2CROWS", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.CDLRICKSHAWMAN", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_outinteger);
@@ -19689,99 +22325,129 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_170CDLUPSIDEGAP2CROWS(CYTHON_UNUSED Py
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_173CDLXSIDEGAP3METHODS(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_172CDLXSIDEGAP3METHODS[] = " CDLXSIDEGAP3METHODS(open, high, low, close)\n\n    Upside/Downside Gap Three Methods (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_173CDLXSIDEGAP3METHODS = {"CDLXSIDEGAP3METHODS", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_173CDLXSIDEGAP3METHODS, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_172CDLXSIDEGAP3METHODS};
-static PyObject *__pyx_pw_5talib_7_ta_lib_173CDLXSIDEGAP3METHODS(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_151CDLRISEFALL3METHODS(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_150CDLRISEFALL3METHODS, "CDLRISEFALL3METHODS(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLRISEFALL3METHODS(open, high, low, close)\n\nRising/Falling Three Methods (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_151CDLRISEFALL3METHODS = {"CDLRISEFALL3METHODS", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_151CDLRISEFALL3METHODS, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_150CDLRISEFALL3METHODS};
+static PyObject *__pyx_pw_5talib_7_ta_lib_151CDLRISEFALL3METHODS(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_open = 0;
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("CDLXSIDEGAP3METHODS (wrapper)", 0);
+  __Pyx_RefNannySetupContext("CDLRISEFALL3METHODS (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 2284, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 2284, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 2284, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2284, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2284, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLXSIDEGAP3METHODS", 1, 4, 4, 1); __PYX_ERR(2, 2632, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLXSIDEGAP3METHODS", 1, 4, 4, 2); __PYX_ERR(2, 2632, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CDLXSIDEGAP3METHODS", 1, 4, 4, 3); __PYX_ERR(2, 2632, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "CDLXSIDEGAP3METHODS") < 0)) __PYX_ERR(2, 2632, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLRISEFALL3METHODS", 0) < (0)) __PYX_ERR(4, 2284, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLRISEFALL3METHODS", 1, 4, 4, i); __PYX_ERR(4, 2284, __pyx_L3_error) }
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
+    } else if (unlikely(__pyx_nargs != 4)) {
       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[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2284, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2284, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 2284, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 2284, __pyx_L3_error)
     }
     __pyx_v_open = ((PyArrayObject *)values[0]);
     __pyx_v_high = ((PyArrayObject *)values[1]);
     __pyx_v_low = ((PyArrayObject *)values[2]);
     __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("CDLXSIDEGAP3METHODS", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 2632, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("CDLRISEFALL3METHODS", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 2284, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.CDLXSIDEGAP3METHODS", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.CDLRISEFALL3METHODS", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(2, 2632, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(2, 2632, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(2, 2632, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(2, 2632, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_172CDLXSIDEGAP3METHODS(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 2286, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 2286, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 2286, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 2286, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_150CDLRISEFALL3METHODS(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_172CDLXSIDEGAP3METHODS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_150CDLRISEFALL3METHODS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -19795,55 +22461,58 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_172CDLXSIDEGAP3METHODS(CYTHON_UNUSED P
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
   npy_int __pyx_t_3;
-  __Pyx_RefNannySetupContext("CDLXSIDEGAP3METHODS", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("CDLRISEFALL3METHODS", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_open);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2649, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2303, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2650, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2304, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2651, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2305, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2652, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2306, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(2, 2653, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 2307, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
-  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_v_open->data), ((double *)__pyx_v_high->data), ((double *)__pyx_v_low->data), ((double *)__pyx_v_close->data)); if (unlikely(__pyx_t_3 == ((npy_int)-1))) __PYX_ERR(2, 2654, __pyx_L1_error)
+  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 2308, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_3;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLXSIDEGAP3METHODS_Lookback());
+  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLRISEFALL3METHODS_Lookback());
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2657, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2311, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_CDLXSIDEGAP3METHODS(0, __pyx_v_endidx, (((double *)__pyx_v_open->data) + __pyx_v_begidx), (((double *)__pyx_v_high->data) + __pyx_v_begidx), (((double *)__pyx_v_low->data) + __pyx_v_begidx), (((double *)__pyx_v_close->data) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_v_outinteger->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_CDLRISEFALL3METHODS(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLXSIDEGAP3METHODS, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2659, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLRISEFALL3METHODS, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2313, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outinteger));
+  __Pyx_INCREF((PyObject *)__pyx_v_outinteger);
   __pyx_r = ((PyObject *)__pyx_v_outinteger);
   goto __pyx_L0;
 
@@ -19851,7 +22520,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_172CDLXSIDEGAP3METHODS(CYTHON_UNUSED P
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.CDLXSIDEGAP3METHODS", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.CDLRISEFALL3METHODS", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_outinteger);
@@ -19866,26 +22535,129 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_172CDLXSIDEGAP3METHODS(CYTHON_UNUSED P
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_175CEIL(PyObject *__pyx_self, PyObject *__pyx_v_real); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_174CEIL[] = " CEIL(real)\n\n    Vector Ceil (Math Transform)\n\n    Inputs:\n        real: (any ndarray)\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_175CEIL = {"CEIL", (PyCFunction)__pyx_pw_5talib_7_ta_lib_175CEIL, METH_O, __pyx_doc_5talib_7_ta_lib_174CEIL};
-static PyObject *__pyx_pw_5talib_7_ta_lib_175CEIL(PyObject *__pyx_self, PyObject *__pyx_v_real) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_153CDLSEPARATINGLINES(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_152CDLSEPARATINGLINES, "CDLSEPARATINGLINES(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLSEPARATINGLINES(open, high, low, close)\n\nSeparating Lines (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_153CDLSEPARATINGLINES = {"CDLSEPARATINGLINES", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_153CDLSEPARATINGLINES, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_152CDLSEPARATINGLINES};
+static PyObject *__pyx_pw_5talib_7_ta_lib_153CDLSEPARATINGLINES(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_open = 0;
+  PyArrayObject *__pyx_v_high = 0;
+  PyArrayObject *__pyx_v_low = 0;
+  PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("CEIL (wrapper)", 0);
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(2, 2664, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_174CEIL(__pyx_self, ((PyArrayObject *)__pyx_v_real));
+  __Pyx_RefNannySetupContext("CDLSEPARATINGLINES (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 2316, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 2316, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 2316, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2316, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2316, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLSEPARATINGLINES", 0) < (0)) __PYX_ERR(4, 2316, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLSEPARATINGLINES", 1, 4, 4, i); __PYX_ERR(4, 2316, __pyx_L3_error) }
+      }
+    } else if (unlikely(__pyx_nargs != 4)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2316, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2316, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 2316, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 2316, __pyx_L3_error)
+    }
+    __pyx_v_open = ((PyArrayObject *)values[0]);
+    __pyx_v_high = ((PyArrayObject *)values[1]);
+    __pyx_v_low = ((PyArrayObject *)values[2]);
+    __pyx_v_close = ((PyArrayObject *)values[3]);
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("CDLSEPARATINGLINES", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 2316, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.CDLSEPARATINGLINES", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 2318, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 2318, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 2318, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 2318, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_152CDLSEPARATINGLINES(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_174CEIL(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_152CDLSEPARATINGLINES(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -19893,53 +22665,79 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_174CEIL(CYTHON_UNUSED PyObject *__pyx_
   TA_RetCode __pyx_v_retCode;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  PyArrayObject *__pyx_v_outreal = 0;
+  PyArrayObject *__pyx_v_outinteger = 0;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  npy_int __pyx_t_2;
-  __Pyx_RefNannySetupContext("CEIL", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_real);
+  npy_intp __pyx_t_2;
+  npy_int __pyx_t_3;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("CDLSEPARATINGLINES", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_open);
+  __Pyx_INCREF((PyObject *)__pyx_v_high);
+  __Pyx_INCREF((PyObject *)__pyx_v_low);
+  __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2681, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2335, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2336, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_v_real->data)); if (unlikely(__pyx_t_2 == ((npy_int)-1))) __PYX_ERR(2, 2683, __pyx_L1_error)
-  __pyx_v_begidx = __pyx_t_2;
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2337, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
+
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2338, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
+
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 2339, __pyx_L1_error)
+  __pyx_v_length = __pyx_t_2;
+
+  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 2340, __pyx_L1_error)
+  __pyx_v_begidx = __pyx_t_3;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_CEIL_Lookback());
+  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLSEPARATINGLINES_Lookback());
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2686, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2343, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
+  __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_CEIL(0, __pyx_v_endidx, (((double *)__pyx_v_real->data) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_v_outreal->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_CDLSEPARATINGLINES(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CEIL, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2688, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLSEPARATINGLINES, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2345, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outreal));
-  __pyx_r = ((PyObject *)__pyx_v_outreal);
+  __Pyx_INCREF((PyObject *)__pyx_v_outinteger);
+  __pyx_r = ((PyObject *)__pyx_v_outinteger);
   goto __pyx_L0;
 
 
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.CEIL", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.CDLSEPARATINGLINES", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
-  __Pyx_XDECREF((PyObject *)__pyx_v_real);
+  __Pyx_XDECREF((PyObject *)__pyx_v_outinteger);
+  __Pyx_XDECREF((PyObject *)__pyx_v_open);
+  __Pyx_XDECREF((PyObject *)__pyx_v_high);
+  __Pyx_XDECREF((PyObject *)__pyx_v_low);
+  __Pyx_XDECREF((PyObject *)__pyx_v_close);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -19947,81 +22745,129 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_174CEIL(CYTHON_UNUSED PyObject *__pyx_
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_177CMO(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_176CMO[] = " CMO(real[, timeperiod=?])\n\n    Chande Momentum Oscillator (Momentum Indicators)\n\n    Inputs:\n        real: (any ndarray)\n    Parameters:\n        timeperiod: 14\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_177CMO = {"CMO", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_177CMO, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_176CMO};
-static PyObject *__pyx_pw_5talib_7_ta_lib_177CMO(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_real = 0;
-  int __pyx_v_timeperiod;
+static PyObject *__pyx_pw_5talib_7_ta_lib_155CDLSHOOTINGSTAR(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_154CDLSHOOTINGSTAR, "CDLSHOOTINGSTAR(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLSHOOTINGSTAR(open, high, low, close)\n\nShooting Star (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_155CDLSHOOTINGSTAR = {"CDLSHOOTINGSTAR", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_155CDLSHOOTINGSTAR, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_154CDLSHOOTINGSTAR};
+static PyObject *__pyx_pw_5talib_7_ta_lib_155CDLSHOOTINGSTAR(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_open = 0;
+  PyArrayObject *__pyx_v_high = 0;
+  PyArrayObject *__pyx_v_low = 0;
+  PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("CMO (wrapper)", 0);
+  __Pyx_RefNannySetupContext("CDLSHOOTINGSTAR (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,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);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 2348, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 2348, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 2348, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  0: break;
-        default: goto __pyx_L5_argtuple_error;
-      }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2348, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  1:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod);
-          if (value) { values[1] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "CMO") < 0)) __PYX_ERR(2, 2693, __pyx_L3_error)
-      }
-    } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2348, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-        break;
+        case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-    }
-    __pyx_v_real = ((PyArrayObject *)values[0]);
-    if (values[1]) {
-      __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 2693, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLSHOOTINGSTAR", 0) < (0)) __PYX_ERR(4, 2348, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLSHOOTINGSTAR", 1, 4, 4, i); __PYX_ERR(4, 2348, __pyx_L3_error) }
+      }
+    } else if (unlikely(__pyx_nargs != 4)) {
+      goto __pyx_L5_argtuple_error;
     } else {
-      __pyx_v_timeperiod = ((int)-2147483648);
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2348, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2348, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 2348, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 2348, __pyx_L3_error)
     }
+    __pyx_v_open = ((PyArrayObject *)values[0]);
+    __pyx_v_high = ((PyArrayObject *)values[1]);
+    __pyx_v_low = ((PyArrayObject *)values[2]);
+    __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("CMO", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 2693, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("CDLSHOOTINGSTAR", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 2348, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.CMO", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.CDLSHOOTINGSTAR", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(2, 2693, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_176CMO(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 2350, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 2350, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 2350, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 2350, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_154CDLSHOOTINGSTAR(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_176CMO(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_154CDLSHOOTINGSTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -20029,53 +22875,79 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_176CMO(CYTHON_UNUSED PyObject *__pyx_s
   TA_RetCode __pyx_v_retCode;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  PyArrayObject *__pyx_v_outreal = 0;
+  PyArrayObject *__pyx_v_outinteger = 0;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  npy_int __pyx_t_2;
-  __Pyx_RefNannySetupContext("CMO", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_real);
+  npy_intp __pyx_t_2;
+  npy_int __pyx_t_3;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("CDLSHOOTINGSTAR", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_open);
+  __Pyx_INCREF((PyObject *)__pyx_v_high);
+  __Pyx_INCREF((PyObject *)__pyx_v_low);
+  __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2712, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2367, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2368, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_v_real->data)); if (unlikely(__pyx_t_2 == ((npy_int)-1))) __PYX_ERR(2, 2714, __pyx_L1_error)
-  __pyx_v_begidx = __pyx_t_2;
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2369, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
+
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2370, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
+
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 2371, __pyx_L1_error)
+  __pyx_v_length = __pyx_t_2;
+
+  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 2372, __pyx_L1_error)
+  __pyx_v_begidx = __pyx_t_3;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_CMO_Lookback(__pyx_v_timeperiod));
+  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLSHOOTINGSTAR_Lookback());
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2717, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2375, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
+  __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_CMO(0, __pyx_v_endidx, (((double *)__pyx_v_real->data) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_v_outreal->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_CDLSHOOTINGSTAR(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CMO, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2719, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLSHOOTINGSTAR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2377, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outreal));
-  __pyx_r = ((PyObject *)__pyx_v_outreal);
+  __Pyx_INCREF((PyObject *)__pyx_v_outinteger);
+  __pyx_r = ((PyObject *)__pyx_v_outinteger);
   goto __pyx_L0;
 
 
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.CMO", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.CDLSHOOTINGSTAR", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
-  __Pyx_XDECREF((PyObject *)__pyx_v_real);
+  __Pyx_XDECREF((PyObject *)__pyx_v_outinteger);
+  __Pyx_XDECREF((PyObject *)__pyx_v_open);
+  __Pyx_XDECREF((PyObject *)__pyx_v_high);
+  __Pyx_XDECREF((PyObject *)__pyx_v_low);
+  __Pyx_XDECREF((PyObject *)__pyx_v_close);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -20083,93 +22955,129 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_176CMO(CYTHON_UNUSED PyObject *__pyx_s
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_179CORREL(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_178CORREL[] = " CORREL(real0, real1[, timeperiod=?])\n\n    Pearson's Correlation Coefficient (r) (Statistic Functions)\n\n    Inputs:\n        real0: (any ndarray)\n        real1: (any ndarray)\n    Parameters:\n        timeperiod: 30\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_179CORREL = {"CORREL", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_179CORREL, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_178CORREL};
-static PyObject *__pyx_pw_5talib_7_ta_lib_179CORREL(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_real0 = 0;
-  PyArrayObject *__pyx_v_real1 = 0;
-  int __pyx_v_timeperiod;
+static PyObject *__pyx_pw_5talib_7_ta_lib_157CDLSHORTLINE(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_156CDLSHORTLINE, "CDLSHORTLINE(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLSHORTLINE(open, high, low, close)\n\nShort Line Candle (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_157CDLSHORTLINE = {"CDLSHORTLINE", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_157CDLSHORTLINE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_156CDLSHORTLINE};
+static PyObject *__pyx_pw_5talib_7_ta_lib_157CDLSHORTLINE(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_open = 0;
+  PyArrayObject *__pyx_v_high = 0;
+  PyArrayObject *__pyx_v_low = 0;
+  PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("CORREL (wrapper)", 0);
+  __Pyx_RefNannySetupContext("CDLSHORTLINE (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real0,&__pyx_n_s_real1,&__pyx_n_s_timeperiod,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);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 2380, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 2380, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 2380, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  0: break;
-        default: goto __pyx_L5_argtuple_error;
-      }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real0)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2380, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real1)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("CORREL", 0, 2, 3, 1); __PYX_ERR(2, 2724, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod);
-          if (value) { values[2] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "CORREL") < 0)) __PYX_ERR(2, 2724, __pyx_L3_error)
-      }
-    } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2380, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-        break;
+        case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-    }
-    __pyx_v_real0 = ((PyArrayObject *)values[0]);
-    __pyx_v_real1 = ((PyArrayObject *)values[1]);
-    if (values[2]) {
-      __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 2724, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLSHORTLINE", 0) < (0)) __PYX_ERR(4, 2380, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLSHORTLINE", 1, 4, 4, i); __PYX_ERR(4, 2380, __pyx_L3_error) }
+      }
+    } else if (unlikely(__pyx_nargs != 4)) {
+      goto __pyx_L5_argtuple_error;
     } else {
-      __pyx_v_timeperiod = ((int)-2147483648);
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2380, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2380, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 2380, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 2380, __pyx_L3_error)
     }
+    __pyx_v_open = ((PyArrayObject *)values[0]);
+    __pyx_v_high = ((PyArrayObject *)values[1]);
+    __pyx_v_low = ((PyArrayObject *)values[2]);
+    __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("CORREL", 0, 2, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 2724, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("CDLSHORTLINE", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 2380, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.CORREL", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.CDLSHORTLINE", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real0), __pyx_ptype_5numpy_ndarray, 0, "real0", 0))) __PYX_ERR(2, 2724, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real1), __pyx_ptype_5numpy_ndarray, 0, "real1", 0))) __PYX_ERR(2, 2724, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_178CORREL(__pyx_self, __pyx_v_real0, __pyx_v_real1, __pyx_v_timeperiod);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 2382, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 2382, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 2382, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 2382, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_156CDLSHORTLINE(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_178CORREL(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real0, PyArrayObject *__pyx_v_real1, int __pyx_v_timeperiod) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_156CDLSHORTLINE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -20177,62 +23085,79 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_178CORREL(CYTHON_UNUSED PyObject *__py
   TA_RetCode __pyx_v_retCode;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  PyArrayObject *__pyx_v_outreal = 0;
+  PyArrayObject *__pyx_v_outinteger = 0;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
   npy_int __pyx_t_3;
-  __Pyx_RefNannySetupContext("CORREL", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_real0);
-  __Pyx_INCREF((PyObject *)__pyx_v_real1);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("CDLSHORTLINE", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_open);
+  __Pyx_INCREF((PyObject *)__pyx_v_high);
+  __Pyx_INCREF((PyObject *)__pyx_v_low);
+  __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2744, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2399, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_real0, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2745, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2400, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_real1, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
+
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2401, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
+
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2402, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_real0, __pyx_v_real1); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(2, 2746, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 2403, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
-  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx2(__pyx_v_length, ((double *)__pyx_v_real0->data), ((double *)__pyx_v_real1->data)); if (unlikely(__pyx_t_3 == ((npy_int)-1))) __PYX_ERR(2, 2747, __pyx_L1_error)
+  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 2404, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_3;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_CORREL_Lookback(__pyx_v_timeperiod));
+  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLSHORTLINE_Lookback());
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2750, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2407, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
+  __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_CORREL(0, __pyx_v_endidx, (((double *)__pyx_v_real0->data) + __pyx_v_begidx), (((double *)__pyx_v_real1->data) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_v_outreal->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_CDLSHORTLINE(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CORREL, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2752, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLSHORTLINE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2409, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outreal));
-  __pyx_r = ((PyObject *)__pyx_v_outreal);
+  __Pyx_INCREF((PyObject *)__pyx_v_outinteger);
+  __pyx_r = ((PyObject *)__pyx_v_outinteger);
   goto __pyx_L0;
 
 
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.CORREL", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.CDLSHORTLINE", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
-  __Pyx_XDECREF((PyObject *)__pyx_v_real0);
-  __Pyx_XDECREF((PyObject *)__pyx_v_real1);
+  __Pyx_XDECREF((PyObject *)__pyx_v_outinteger);
+  __Pyx_XDECREF((PyObject *)__pyx_v_open);
+  __Pyx_XDECREF((PyObject *)__pyx_v_high);
+  __Pyx_XDECREF((PyObject *)__pyx_v_low);
+  __Pyx_XDECREF((PyObject *)__pyx_v_close);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -20240,26 +23165,129 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_178CORREL(CYTHON_UNUSED PyObject *__py
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_181COS(PyObject *__pyx_self, PyObject *__pyx_v_real); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_180COS[] = " COS(real)\n\n    Vector Trigonometric Cos (Math Transform)\n\n    Inputs:\n        real: (any ndarray)\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_181COS = {"COS", (PyCFunction)__pyx_pw_5talib_7_ta_lib_181COS, METH_O, __pyx_doc_5talib_7_ta_lib_180COS};
-static PyObject *__pyx_pw_5talib_7_ta_lib_181COS(PyObject *__pyx_self, PyObject *__pyx_v_real) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_159CDLSPINNINGTOP(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_158CDLSPINNINGTOP, "CDLSPINNINGTOP(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLSPINNINGTOP(open, high, low, close)\n\nSpinning Top (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_159CDLSPINNINGTOP = {"CDLSPINNINGTOP", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_159CDLSPINNINGTOP, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_158CDLSPINNINGTOP};
+static PyObject *__pyx_pw_5talib_7_ta_lib_159CDLSPINNINGTOP(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_open = 0;
+  PyArrayObject *__pyx_v_high = 0;
+  PyArrayObject *__pyx_v_low = 0;
+  PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("COS (wrapper)", 0);
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(2, 2757, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_180COS(__pyx_self, ((PyArrayObject *)__pyx_v_real));
+  __Pyx_RefNannySetupContext("CDLSPINNINGTOP (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 2412, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 2412, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 2412, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2412, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2412, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLSPINNINGTOP", 0) < (0)) __PYX_ERR(4, 2412, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLSPINNINGTOP", 1, 4, 4, i); __PYX_ERR(4, 2412, __pyx_L3_error) }
+      }
+    } else if (unlikely(__pyx_nargs != 4)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2412, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2412, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 2412, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 2412, __pyx_L3_error)
+    }
+    __pyx_v_open = ((PyArrayObject *)values[0]);
+    __pyx_v_high = ((PyArrayObject *)values[1]);
+    __pyx_v_low = ((PyArrayObject *)values[2]);
+    __pyx_v_close = ((PyArrayObject *)values[3]);
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("CDLSPINNINGTOP", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 2412, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.CDLSPINNINGTOP", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 2414, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 2414, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 2414, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 2414, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_158CDLSPINNINGTOP(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_180COS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_158CDLSPINNINGTOP(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -20267,53 +23295,79 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_180COS(CYTHON_UNUSED PyObject *__pyx_s
   TA_RetCode __pyx_v_retCode;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  PyArrayObject *__pyx_v_outreal = 0;
+  PyArrayObject *__pyx_v_outinteger = 0;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  npy_int __pyx_t_2;
-  __Pyx_RefNannySetupContext("COS", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_real);
+  npy_intp __pyx_t_2;
+  npy_int __pyx_t_3;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("CDLSPINNINGTOP", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_open);
+  __Pyx_INCREF((PyObject *)__pyx_v_high);
+  __Pyx_INCREF((PyObject *)__pyx_v_low);
+  __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2774, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2431, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2432, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_v_real->data)); if (unlikely(__pyx_t_2 == ((npy_int)-1))) __PYX_ERR(2, 2776, __pyx_L1_error)
-  __pyx_v_begidx = __pyx_t_2;
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2433, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
+
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2434, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
+
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 2435, __pyx_L1_error)
+  __pyx_v_length = __pyx_t_2;
+
+  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 2436, __pyx_L1_error)
+  __pyx_v_begidx = __pyx_t_3;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_COS_Lookback());
+  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLSPINNINGTOP_Lookback());
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2779, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2439, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
+  __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_COS(0, __pyx_v_endidx, (((double *)__pyx_v_real->data) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_v_outreal->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_CDLSPINNINGTOP(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_COS, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2781, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLSPINNINGTOP, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2441, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outreal));
-  __pyx_r = ((PyObject *)__pyx_v_outreal);
+  __Pyx_INCREF((PyObject *)__pyx_v_outinteger);
+  __pyx_r = ((PyObject *)__pyx_v_outinteger);
   goto __pyx_L0;
 
 
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.COS", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.CDLSPINNINGTOP", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
-  __Pyx_XDECREF((PyObject *)__pyx_v_real);
+  __Pyx_XDECREF((PyObject *)__pyx_v_outinteger);
+  __Pyx_XDECREF((PyObject *)__pyx_v_open);
+  __Pyx_XDECREF((PyObject *)__pyx_v_high);
+  __Pyx_XDECREF((PyObject *)__pyx_v_low);
+  __Pyx_XDECREF((PyObject *)__pyx_v_close);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -20321,26 +23375,129 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_180COS(CYTHON_UNUSED PyObject *__pyx_s
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_183COSH(PyObject *__pyx_self, PyObject *__pyx_v_real); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_182COSH[] = " COSH(real)\n\n    Vector Trigonometric Cosh (Math Transform)\n\n    Inputs:\n        real: (any ndarray)\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_183COSH = {"COSH", (PyCFunction)__pyx_pw_5talib_7_ta_lib_183COSH, METH_O, __pyx_doc_5talib_7_ta_lib_182COSH};
-static PyObject *__pyx_pw_5talib_7_ta_lib_183COSH(PyObject *__pyx_self, PyObject *__pyx_v_real) {
-  PyObject *__pyx_r = 0;
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("COSH (wrapper)", 0);
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(2, 2786, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_182COSH(__pyx_self, ((PyArrayObject *)__pyx_v_real));
-
-  /* function exit code */
-  goto __pyx_L0;
+static PyObject *__pyx_pw_5talib_7_ta_lib_161CDLSTALLEDPATTERN(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_160CDLSTALLEDPATTERN, "CDLSTALLEDPATTERN(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLSTALLEDPATTERN(open, high, low, close)\n\nStalled Pattern (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_161CDLSTALLEDPATTERN = {"CDLSTALLEDPATTERN", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_161CDLSTALLEDPATTERN, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_160CDLSTALLEDPATTERN};
+static PyObject *__pyx_pw_5talib_7_ta_lib_161CDLSTALLEDPATTERN(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_open = 0;
+  PyArrayObject *__pyx_v_high = 0;
+  PyArrayObject *__pyx_v_low = 0;
+  PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("CDLSTALLEDPATTERN (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 2444, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 2444, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 2444, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2444, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2444, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLSTALLEDPATTERN", 0) < (0)) __PYX_ERR(4, 2444, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLSTALLEDPATTERN", 1, 4, 4, i); __PYX_ERR(4, 2444, __pyx_L3_error) }
+      }
+    } else if (unlikely(__pyx_nargs != 4)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2444, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2444, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 2444, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 2444, __pyx_L3_error)
+    }
+    __pyx_v_open = ((PyArrayObject *)values[0]);
+    __pyx_v_high = ((PyArrayObject *)values[1]);
+    __pyx_v_low = ((PyArrayObject *)values[2]);
+    __pyx_v_close = ((PyArrayObject *)values[3]);
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("CDLSTALLEDPATTERN", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 2444, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.CDLSTALLEDPATTERN", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 2446, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 2446, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 2446, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 2446, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_160CDLSTALLEDPATTERN(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+
+  /* function exit code */
+  goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_182COSH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_160CDLSTALLEDPATTERN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -20348,53 +23505,79 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_182COSH(CYTHON_UNUSED PyObject *__pyx_
   TA_RetCode __pyx_v_retCode;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  PyArrayObject *__pyx_v_outreal = 0;
+  PyArrayObject *__pyx_v_outinteger = 0;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  npy_int __pyx_t_2;
-  __Pyx_RefNannySetupContext("COSH", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_real);
+  npy_intp __pyx_t_2;
+  npy_int __pyx_t_3;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("CDLSTALLEDPATTERN", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_open);
+  __Pyx_INCREF((PyObject *)__pyx_v_high);
+  __Pyx_INCREF((PyObject *)__pyx_v_low);
+  __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2803, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2463, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
+
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2464, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2465, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_v_real->data)); if (unlikely(__pyx_t_2 == ((npy_int)-1))) __PYX_ERR(2, 2805, __pyx_L1_error)
-  __pyx_v_begidx = __pyx_t_2;
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2466, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
+
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 2467, __pyx_L1_error)
+  __pyx_v_length = __pyx_t_2;
+
+  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 2468, __pyx_L1_error)
+  __pyx_v_begidx = __pyx_t_3;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_COSH_Lookback());
+  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLSTALLEDPATTERN_Lookback());
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2808, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2471, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
+  __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_COSH(0, __pyx_v_endidx, (((double *)__pyx_v_real->data) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_v_outreal->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_CDLSTALLEDPATTERN(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_COSH, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2810, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLSTALLEDPATTERN, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2473, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outreal));
-  __pyx_r = ((PyObject *)__pyx_v_outreal);
+  __Pyx_INCREF((PyObject *)__pyx_v_outinteger);
+  __pyx_r = ((PyObject *)__pyx_v_outinteger);
   goto __pyx_L0;
 
 
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.COSH", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.CDLSTALLEDPATTERN", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
-  __Pyx_XDECREF((PyObject *)__pyx_v_real);
+  __Pyx_XDECREF((PyObject *)__pyx_v_outinteger);
+  __Pyx_XDECREF((PyObject *)__pyx_v_open);
+  __Pyx_XDECREF((PyObject *)__pyx_v_high);
+  __Pyx_XDECREF((PyObject *)__pyx_v_low);
+  __Pyx_XDECREF((PyObject *)__pyx_v_close);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -20402,81 +23585,129 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_182COSH(CYTHON_UNUSED PyObject *__pyx_
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_185DEMA(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_184DEMA[] = " DEMA(real[, timeperiod=?])\n\n    Double Exponential Moving Average (Overlap Studies)\n\n    Inputs:\n        real: (any ndarray)\n    Parameters:\n        timeperiod: 30\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_185DEMA = {"DEMA", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_185DEMA, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_184DEMA};
-static PyObject *__pyx_pw_5talib_7_ta_lib_185DEMA(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_real = 0;
-  int __pyx_v_timeperiod;
+static PyObject *__pyx_pw_5talib_7_ta_lib_163CDLSTICKSANDWICH(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_162CDLSTICKSANDWICH, "CDLSTICKSANDWICH(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLSTICKSANDWICH(open, high, low, close)\n\nStick Sandwich (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_163CDLSTICKSANDWICH = {"CDLSTICKSANDWICH", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_163CDLSTICKSANDWICH, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_162CDLSTICKSANDWICH};
+static PyObject *__pyx_pw_5talib_7_ta_lib_163CDLSTICKSANDWICH(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_open = 0;
+  PyArrayObject *__pyx_v_high = 0;
+  PyArrayObject *__pyx_v_low = 0;
+  PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("DEMA (wrapper)", 0);
+  __Pyx_RefNannySetupContext("CDLSTICKSANDWICH (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,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);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 2476, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 2476, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 2476, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  0: break;
-        default: goto __pyx_L5_argtuple_error;
-      }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2476, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  1:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod);
-          if (value) { values[1] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "DEMA") < 0)) __PYX_ERR(2, 2815, __pyx_L3_error)
-      }
-    } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2476, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-        break;
+        case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-    }
-    __pyx_v_real = ((PyArrayObject *)values[0]);
-    if (values[1]) {
-      __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 2815, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLSTICKSANDWICH", 0) < (0)) __PYX_ERR(4, 2476, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLSTICKSANDWICH", 1, 4, 4, i); __PYX_ERR(4, 2476, __pyx_L3_error) }
+      }
+    } else if (unlikely(__pyx_nargs != 4)) {
+      goto __pyx_L5_argtuple_error;
     } else {
-      __pyx_v_timeperiod = ((int)-2147483648);
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2476, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2476, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 2476, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 2476, __pyx_L3_error)
     }
+    __pyx_v_open = ((PyArrayObject *)values[0]);
+    __pyx_v_high = ((PyArrayObject *)values[1]);
+    __pyx_v_low = ((PyArrayObject *)values[2]);
+    __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("DEMA", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 2815, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("CDLSTICKSANDWICH", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 2476, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.DEMA", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.CDLSTICKSANDWICH", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(2, 2815, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_184DEMA(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 2478, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 2478, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 2478, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 2478, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_162CDLSTICKSANDWICH(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_184DEMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_162CDLSTICKSANDWICH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -20484,53 +23715,79 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_184DEMA(CYTHON_UNUSED PyObject *__pyx_
   TA_RetCode __pyx_v_retCode;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  PyArrayObject *__pyx_v_outreal = 0;
+  PyArrayObject *__pyx_v_outinteger = 0;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  npy_int __pyx_t_2;
-  __Pyx_RefNannySetupContext("DEMA", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_real);
+  npy_intp __pyx_t_2;
+  npy_int __pyx_t_3;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("CDLSTICKSANDWICH", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_open);
+  __Pyx_INCREF((PyObject *)__pyx_v_high);
+  __Pyx_INCREF((PyObject *)__pyx_v_low);
+  __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2834, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2495, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
+
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2496, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2497, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_v_real->data)); if (unlikely(__pyx_t_2 == ((npy_int)-1))) __PYX_ERR(2, 2836, __pyx_L1_error)
-  __pyx_v_begidx = __pyx_t_2;
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2498, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
+
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 2499, __pyx_L1_error)
+  __pyx_v_length = __pyx_t_2;
+
+  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 2500, __pyx_L1_error)
+  __pyx_v_begidx = __pyx_t_3;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_DEMA_Lookback(__pyx_v_timeperiod));
+  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLSTICKSANDWICH_Lookback());
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2839, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2503, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
+  __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_DEMA(0, __pyx_v_endidx, (((double *)__pyx_v_real->data) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_v_outreal->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_CDLSTICKSANDWICH(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_DEMA, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2841, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLSTICKSANDWICH, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2505, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outreal));
-  __pyx_r = ((PyObject *)__pyx_v_outreal);
+  __Pyx_INCREF((PyObject *)__pyx_v_outinteger);
+  __pyx_r = ((PyObject *)__pyx_v_outinteger);
   goto __pyx_L0;
 
 
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.DEMA", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.CDLSTICKSANDWICH", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
-  __Pyx_XDECREF((PyObject *)__pyx_v_real);
+  __Pyx_XDECREF((PyObject *)__pyx_v_outinteger);
+  __Pyx_XDECREF((PyObject *)__pyx_v_open);
+  __Pyx_XDECREF((PyObject *)__pyx_v_high);
+  __Pyx_XDECREF((PyObject *)__pyx_v_low);
+  __Pyx_XDECREF((PyObject *)__pyx_v_close);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -20538,75 +23795,129 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_184DEMA(CYTHON_UNUSED PyObject *__pyx_
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_187DIV(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_186DIV[] = " DIV(real0, real1)\n\n    Vector Arithmetic Div (Math Operators)\n\n    Inputs:\n        real0: (any ndarray)\n        real1: (any ndarray)\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_187DIV = {"DIV", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_187DIV, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_186DIV};
-static PyObject *__pyx_pw_5talib_7_ta_lib_187DIV(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_real0 = 0;
-  PyArrayObject *__pyx_v_real1 = 0;
+static PyObject *__pyx_pw_5talib_7_ta_lib_165CDLTAKURI(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_164CDLTAKURI, "CDLTAKURI(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLTAKURI(open, high, low, close)\n\nTakuri (Dragonfly Doji with very long lower shadow) (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_165CDLTAKURI = {"CDLTAKURI", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_165CDLTAKURI, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_164CDLTAKURI};
+static PyObject *__pyx_pw_5talib_7_ta_lib_165CDLTAKURI(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_open = 0;
+  PyArrayObject *__pyx_v_high = 0;
+  PyArrayObject *__pyx_v_low = 0;
+  PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("DIV (wrapper)", 0);
+  __Pyx_RefNannySetupContext("CDLTAKURI (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real0,&__pyx_n_s_real1,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);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 2508, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 2508, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 2508, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  0: break;
-        default: goto __pyx_L5_argtuple_error;
-      }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real0)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2508, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real1)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("DIV", 1, 2, 2, 1); __PYX_ERR(2, 2846, __pyx_L3_error)
-        }
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2508, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
       }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "DIV") < 0)) __PYX_ERR(2, 2846, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLTAKURI", 0) < (0)) __PYX_ERR(4, 2508, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLTAKURI", 1, 4, 4, i); __PYX_ERR(4, 2508, __pyx_L3_error) }
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
+    } else if (unlikely(__pyx_nargs != 4)) {
       goto __pyx_L5_argtuple_error;
     } else {
-      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2508, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2508, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 2508, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 2508, __pyx_L3_error)
     }
-    __pyx_v_real0 = ((PyArrayObject *)values[0]);
-    __pyx_v_real1 = ((PyArrayObject *)values[1]);
+    __pyx_v_open = ((PyArrayObject *)values[0]);
+    __pyx_v_high = ((PyArrayObject *)values[1]);
+    __pyx_v_low = ((PyArrayObject *)values[2]);
+    __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("DIV", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 2846, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("CDLTAKURI", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 2508, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.DIV", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.CDLTAKURI", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real0), __pyx_ptype_5numpy_ndarray, 0, "real0", 0))) __PYX_ERR(2, 2846, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real1), __pyx_ptype_5numpy_ndarray, 0, "real1", 0))) __PYX_ERR(2, 2846, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_186DIV(__pyx_self, __pyx_v_real0, __pyx_v_real1);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 2510, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 2510, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 2510, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 2510, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_164CDLTAKURI(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_186DIV(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real0, PyArrayObject *__pyx_v_real1) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_164CDLTAKURI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -20614,62 +23925,79 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_186DIV(CYTHON_UNUSED PyObject *__pyx_s
   TA_RetCode __pyx_v_retCode;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  PyArrayObject *__pyx_v_outreal = 0;
+  PyArrayObject *__pyx_v_outinteger = 0;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
   npy_int __pyx_t_3;
-  __Pyx_RefNannySetupContext("DIV", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_real0);
-  __Pyx_INCREF((PyObject *)__pyx_v_real1);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("CDLTAKURI", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_open);
+  __Pyx_INCREF((PyObject *)__pyx_v_high);
+  __Pyx_INCREF((PyObject *)__pyx_v_low);
+  __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2864, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2527, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_real0, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2865, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2528, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_real1, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
+
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2529, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
+
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2530, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_real0, __pyx_v_real1); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(2, 2866, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 2531, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
-  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx2(__pyx_v_length, ((double *)__pyx_v_real0->data), ((double *)__pyx_v_real1->data)); if (unlikely(__pyx_t_3 == ((npy_int)-1))) __PYX_ERR(2, 2867, __pyx_L1_error)
+  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 2532, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_3;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_DIV_Lookback());
+  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLTAKURI_Lookback());
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2870, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2535, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
+  __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_DIV(0, __pyx_v_endidx, (((double *)__pyx_v_real0->data) + __pyx_v_begidx), (((double *)__pyx_v_real1->data) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_v_outreal->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_CDLTAKURI(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_DIV, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2872, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLTAKURI, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2537, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outreal));
-  __pyx_r = ((PyObject *)__pyx_v_outreal);
+  __Pyx_INCREF((PyObject *)__pyx_v_outinteger);
+  __pyx_r = ((PyObject *)__pyx_v_outinteger);
   goto __pyx_L0;
 
 
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.DIV", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.CDLTAKURI", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
-  __Pyx_XDECREF((PyObject *)__pyx_v_real0);
-  __Pyx_XDECREF((PyObject *)__pyx_v_real1);
+  __Pyx_XDECREF((PyObject *)__pyx_v_outinteger);
+  __Pyx_XDECREF((PyObject *)__pyx_v_open);
+  __Pyx_XDECREF((PyObject *)__pyx_v_high);
+  __Pyx_XDECREF((PyObject *)__pyx_v_low);
+  __Pyx_XDECREF((PyObject *)__pyx_v_close);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -20677,105 +24005,129 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_186DIV(CYTHON_UNUSED PyObject *__pyx_s
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_189DX(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_188DX[] = " DX(high, low, close[, timeperiod=?])\n\n    Directional Movement Index (Momentum Indicators)\n\n    Inputs:\n        prices: ['high', 'low', 'close']\n    Parameters:\n        timeperiod: 14\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_189DX = {"DX", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_189DX, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_188DX};
-static PyObject *__pyx_pw_5talib_7_ta_lib_189DX(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_167CDLTASUKIGAP(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_166CDLTASUKIGAP, "CDLTASUKIGAP(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLTASUKIGAP(open, high, low, close)\n\nTasuki Gap (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_167CDLTASUKIGAP = {"CDLTASUKIGAP", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_167CDLTASUKIGAP, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_166CDLTASUKIGAP};
+static PyObject *__pyx_pw_5talib_7_ta_lib_167CDLTASUKIGAP(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_open = 0;
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
-  int __pyx_v_timeperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("DX (wrapper)", 0);
+  __Pyx_RefNannySetupContext("CDLTASUKIGAP (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,&__pyx_n_s_timeperiod,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 2540, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 2540, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 2540, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2540, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2540, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("DX", 0, 3, 4, 1); __PYX_ERR(2, 2877, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("DX", 0, 3, 4, 2); __PYX_ERR(2, 2877, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod);
-          if (value) { values[3] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "DX") < 0)) __PYX_ERR(2, 2877, __pyx_L3_error)
-      }
-    } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-        break;
-        default: goto __pyx_L5_argtuple_error;
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLTASUKIGAP", 0) < (0)) __PYX_ERR(4, 2540, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLTASUKIGAP", 1, 4, 4, i); __PYX_ERR(4, 2540, __pyx_L3_error) }
       }
-    }
-    __pyx_v_high = ((PyArrayObject *)values[0]);
-    __pyx_v_low = ((PyArrayObject *)values[1]);
-    __pyx_v_close = ((PyArrayObject *)values[2]);
-    if (values[3]) {
-      __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[3]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 2877, __pyx_L3_error)
+    } else if (unlikely(__pyx_nargs != 4)) {
+      goto __pyx_L5_argtuple_error;
     } else {
-      __pyx_v_timeperiod = ((int)-2147483648);
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2540, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2540, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 2540, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 2540, __pyx_L3_error)
     }
+    __pyx_v_open = ((PyArrayObject *)values[0]);
+    __pyx_v_high = ((PyArrayObject *)values[1]);
+    __pyx_v_low = ((PyArrayObject *)values[2]);
+    __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("DX", 0, 3, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 2877, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("CDLTASUKIGAP", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 2540, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.DX", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.CDLTASUKIGAP", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(2, 2877, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(2, 2877, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(2, 2877, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_188DX(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_timeperiod);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 2542, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 2542, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 2542, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 2542, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_166CDLTASUKIGAP(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_188DX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_166CDLTASUKIGAP(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -20783,66 +24135,76 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_188DX(CYTHON_UNUSED PyObject *__pyx_se
   TA_RetCode __pyx_v_retCode;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  PyArrayObject *__pyx_v_outreal = 0;
+  PyArrayObject *__pyx_v_outinteger = 0;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
   npy_int __pyx_t_3;
-  __Pyx_RefNannySetupContext("DX", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("CDLTASUKIGAP", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_open);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2896, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2559, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
+
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2560, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2897, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2561, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2898, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2562, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(2, 2899, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 2563, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
-  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx3(__pyx_v_length, ((double *)__pyx_v_high->data), ((double *)__pyx_v_low->data), ((double *)__pyx_v_close->data)); if (unlikely(__pyx_t_3 == ((npy_int)-1))) __PYX_ERR(2, 2900, __pyx_L1_error)
+  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 2564, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_3;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_DX_Lookback(__pyx_v_timeperiod));
+  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLTASUKIGAP_Lookback());
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2903, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2567, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
+  __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_DX(0, __pyx_v_endidx, (((double *)__pyx_v_high->data) + __pyx_v_begidx), (((double *)__pyx_v_low->data) + __pyx_v_begidx), (((double *)__pyx_v_close->data) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_v_outreal->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_CDLTASUKIGAP(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_DX, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2905, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLTASUKIGAP, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2569, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outreal));
-  __pyx_r = ((PyObject *)__pyx_v_outreal);
+  __Pyx_INCREF((PyObject *)__pyx_v_outinteger);
+  __pyx_r = ((PyObject *)__pyx_v_outinteger);
   goto __pyx_L0;
 
 
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.DX", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.CDLTASUKIGAP", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
+  __Pyx_XDECREF((PyObject *)__pyx_v_outinteger);
+  __Pyx_XDECREF((PyObject *)__pyx_v_open);
   __Pyx_XDECREF((PyObject *)__pyx_v_high);
   __Pyx_XDECREF((PyObject *)__pyx_v_low);
   __Pyx_XDECREF((PyObject *)__pyx_v_close);
@@ -20853,81 +24215,129 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_188DX(CYTHON_UNUSED PyObject *__pyx_se
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_191EMA(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_190EMA[] = " EMA(real[, timeperiod=?])\n\n    Exponential Moving Average (Overlap Studies)\n\n    Inputs:\n        real: (any ndarray)\n    Parameters:\n        timeperiod: 30\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_191EMA = {"EMA", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_191EMA, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_190EMA};
-static PyObject *__pyx_pw_5talib_7_ta_lib_191EMA(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_real = 0;
-  int __pyx_v_timeperiod;
+static PyObject *__pyx_pw_5talib_7_ta_lib_169CDLTHRUSTING(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_168CDLTHRUSTING, "CDLTHRUSTING(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLTHRUSTING(open, high, low, close)\n\nThrusting Pattern (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_169CDLTHRUSTING = {"CDLTHRUSTING", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_169CDLTHRUSTING, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_168CDLTHRUSTING};
+static PyObject *__pyx_pw_5talib_7_ta_lib_169CDLTHRUSTING(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_open = 0;
+  PyArrayObject *__pyx_v_high = 0;
+  PyArrayObject *__pyx_v_low = 0;
+  PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("EMA (wrapper)", 0);
+  __Pyx_RefNannySetupContext("CDLTHRUSTING (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,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);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 2572, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 2572, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 2572, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  0: break;
-        default: goto __pyx_L5_argtuple_error;
-      }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2572, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  1:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod);
-          if (value) { values[1] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "EMA") < 0)) __PYX_ERR(2, 2910, __pyx_L3_error)
-      }
-    } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2572, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-        break;
+        case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-    }
-    __pyx_v_real = ((PyArrayObject *)values[0]);
-    if (values[1]) {
-      __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 2910, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLTHRUSTING", 0) < (0)) __PYX_ERR(4, 2572, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLTHRUSTING", 1, 4, 4, i); __PYX_ERR(4, 2572, __pyx_L3_error) }
+      }
+    } else if (unlikely(__pyx_nargs != 4)) {
+      goto __pyx_L5_argtuple_error;
     } else {
-      __pyx_v_timeperiod = ((int)-2147483648);
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2572, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2572, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 2572, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 2572, __pyx_L3_error)
     }
+    __pyx_v_open = ((PyArrayObject *)values[0]);
+    __pyx_v_high = ((PyArrayObject *)values[1]);
+    __pyx_v_low = ((PyArrayObject *)values[2]);
+    __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("EMA", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 2910, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("CDLTHRUSTING", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 2572, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.EMA", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.CDLTHRUSTING", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(2, 2910, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_190EMA(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 2574, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 2574, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 2574, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 2574, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_168CDLTHRUSTING(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_190EMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_168CDLTHRUSTING(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -20935,53 +24345,79 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_190EMA(CYTHON_UNUSED PyObject *__pyx_s
   TA_RetCode __pyx_v_retCode;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  PyArrayObject *__pyx_v_outreal = 0;
+  PyArrayObject *__pyx_v_outinteger = 0;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  npy_int __pyx_t_2;
-  __Pyx_RefNannySetupContext("EMA", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_real);
+  npy_intp __pyx_t_2;
+  npy_int __pyx_t_3;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("CDLTHRUSTING", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_open);
+  __Pyx_INCREF((PyObject *)__pyx_v_high);
+  __Pyx_INCREF((PyObject *)__pyx_v_low);
+  __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2929, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2591, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2592, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_v_real->data)); if (unlikely(__pyx_t_2 == ((npy_int)-1))) __PYX_ERR(2, 2931, __pyx_L1_error)
-  __pyx_v_begidx = __pyx_t_2;
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2593, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
+
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2594, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
+
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 2595, __pyx_L1_error)
+  __pyx_v_length = __pyx_t_2;
+
+  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 2596, __pyx_L1_error)
+  __pyx_v_begidx = __pyx_t_3;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_EMA_Lookback(__pyx_v_timeperiod));
+  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLTHRUSTING_Lookback());
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2934, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2599, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
+  __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_EMA(0, __pyx_v_endidx, (((double *)__pyx_v_real->data) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_v_outreal->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_CDLTHRUSTING(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_EMA, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2936, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLTHRUSTING, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2601, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outreal));
-  __pyx_r = ((PyObject *)__pyx_v_outreal);
+  __Pyx_INCREF((PyObject *)__pyx_v_outinteger);
+  __pyx_r = ((PyObject *)__pyx_v_outinteger);
   goto __pyx_L0;
 
 
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.EMA", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.CDLTHRUSTING", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
-  __Pyx_XDECREF((PyObject *)__pyx_v_real);
+  __Pyx_XDECREF((PyObject *)__pyx_v_outinteger);
+  __Pyx_XDECREF((PyObject *)__pyx_v_open);
+  __Pyx_XDECREF((PyObject *)__pyx_v_high);
+  __Pyx_XDECREF((PyObject *)__pyx_v_low);
+  __Pyx_XDECREF((PyObject *)__pyx_v_close);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -20989,26 +24425,129 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_190EMA(CYTHON_UNUSED PyObject *__pyx_s
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_193EXP(PyObject *__pyx_self, PyObject *__pyx_v_real); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_192EXP[] = " EXP(real)\n\n    Vector Arithmetic Exp (Math Transform)\n\n    Inputs:\n        real: (any ndarray)\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_193EXP = {"EXP", (PyCFunction)__pyx_pw_5talib_7_ta_lib_193EXP, METH_O, __pyx_doc_5talib_7_ta_lib_192EXP};
-static PyObject *__pyx_pw_5talib_7_ta_lib_193EXP(PyObject *__pyx_self, PyObject *__pyx_v_real) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_171CDLTRISTAR(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_170CDLTRISTAR, "CDLTRISTAR(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLTRISTAR(open, high, low, close)\n\nTristar Pattern (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_171CDLTRISTAR = {"CDLTRISTAR", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_171CDLTRISTAR, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_170CDLTRISTAR};
+static PyObject *__pyx_pw_5talib_7_ta_lib_171CDLTRISTAR(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_open = 0;
+  PyArrayObject *__pyx_v_high = 0;
+  PyArrayObject *__pyx_v_low = 0;
+  PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("EXP (wrapper)", 0);
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(2, 2941, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_192EXP(__pyx_self, ((PyArrayObject *)__pyx_v_real));
+  __Pyx_RefNannySetupContext("CDLTRISTAR (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 2604, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 2604, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 2604, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2604, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2604, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLTRISTAR", 0) < (0)) __PYX_ERR(4, 2604, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLTRISTAR", 1, 4, 4, i); __PYX_ERR(4, 2604, __pyx_L3_error) }
+      }
+    } else if (unlikely(__pyx_nargs != 4)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2604, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2604, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 2604, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 2604, __pyx_L3_error)
+    }
+    __pyx_v_open = ((PyArrayObject *)values[0]);
+    __pyx_v_high = ((PyArrayObject *)values[1]);
+    __pyx_v_low = ((PyArrayObject *)values[2]);
+    __pyx_v_close = ((PyArrayObject *)values[3]);
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("CDLTRISTAR", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 2604, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.CDLTRISTAR", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 2606, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 2606, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 2606, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 2606, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_170CDLTRISTAR(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_192EXP(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_170CDLTRISTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -21016,53 +24555,79 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_192EXP(CYTHON_UNUSED PyObject *__pyx_s
   TA_RetCode __pyx_v_retCode;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  PyArrayObject *__pyx_v_outreal = 0;
+  PyArrayObject *__pyx_v_outinteger = 0;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  npy_int __pyx_t_2;
-  __Pyx_RefNannySetupContext("EXP", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_real);
+  npy_intp __pyx_t_2;
+  npy_int __pyx_t_3;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("CDLTRISTAR", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_open);
+  __Pyx_INCREF((PyObject *)__pyx_v_high);
+  __Pyx_INCREF((PyObject *)__pyx_v_low);
+  __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2958, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2623, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2624, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_v_real->data)); if (unlikely(__pyx_t_2 == ((npy_int)-1))) __PYX_ERR(2, 2960, __pyx_L1_error)
-  __pyx_v_begidx = __pyx_t_2;
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2625, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
+
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2626, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
+
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 2627, __pyx_L1_error)
+  __pyx_v_length = __pyx_t_2;
+
+  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 2628, __pyx_L1_error)
+  __pyx_v_begidx = __pyx_t_3;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_EXP_Lookback());
+  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLTRISTAR_Lookback());
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2963, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2631, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
+  __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_EXP(0, __pyx_v_endidx, (((double *)__pyx_v_real->data) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_v_outreal->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_CDLTRISTAR(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_EXP, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2965, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLTRISTAR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2633, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outreal));
-  __pyx_r = ((PyObject *)__pyx_v_outreal);
+  __Pyx_INCREF((PyObject *)__pyx_v_outinteger);
+  __pyx_r = ((PyObject *)__pyx_v_outinteger);
   goto __pyx_L0;
 
 
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.EXP", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.CDLTRISTAR", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
-  __Pyx_XDECREF((PyObject *)__pyx_v_real);
+  __Pyx_XDECREF((PyObject *)__pyx_v_outinteger);
+  __Pyx_XDECREF((PyObject *)__pyx_v_open);
+  __Pyx_XDECREF((PyObject *)__pyx_v_high);
+  __Pyx_XDECREF((PyObject *)__pyx_v_low);
+  __Pyx_XDECREF((PyObject *)__pyx_v_close);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -21070,26 +24635,129 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_192EXP(CYTHON_UNUSED PyObject *__pyx_s
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_195FLOOR(PyObject *__pyx_self, PyObject *__pyx_v_real); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_194FLOOR[] = " FLOOR(real)\n\n    Vector Floor (Math Transform)\n\n    Inputs:\n        real: (any ndarray)\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_195FLOOR = {"FLOOR", (PyCFunction)__pyx_pw_5talib_7_ta_lib_195FLOOR, METH_O, __pyx_doc_5talib_7_ta_lib_194FLOOR};
-static PyObject *__pyx_pw_5talib_7_ta_lib_195FLOOR(PyObject *__pyx_self, PyObject *__pyx_v_real) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_173CDLUNIQUE3RIVER(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_172CDLUNIQUE3RIVER, "CDLUNIQUE3RIVER(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLUNIQUE3RIVER(open, high, low, close)\n\nUnique 3 River (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_173CDLUNIQUE3RIVER = {"CDLUNIQUE3RIVER", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_173CDLUNIQUE3RIVER, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_172CDLUNIQUE3RIVER};
+static PyObject *__pyx_pw_5talib_7_ta_lib_173CDLUNIQUE3RIVER(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_open = 0;
+  PyArrayObject *__pyx_v_high = 0;
+  PyArrayObject *__pyx_v_low = 0;
+  PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("FLOOR (wrapper)", 0);
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(2, 2970, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_194FLOOR(__pyx_self, ((PyArrayObject *)__pyx_v_real));
+  __Pyx_RefNannySetupContext("CDLUNIQUE3RIVER (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 2636, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 2636, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 2636, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2636, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2636, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLUNIQUE3RIVER", 0) < (0)) __PYX_ERR(4, 2636, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLUNIQUE3RIVER", 1, 4, 4, i); __PYX_ERR(4, 2636, __pyx_L3_error) }
+      }
+    } else if (unlikely(__pyx_nargs != 4)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2636, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2636, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 2636, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 2636, __pyx_L3_error)
+    }
+    __pyx_v_open = ((PyArrayObject *)values[0]);
+    __pyx_v_high = ((PyArrayObject *)values[1]);
+    __pyx_v_low = ((PyArrayObject *)values[2]);
+    __pyx_v_close = ((PyArrayObject *)values[3]);
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("CDLUNIQUE3RIVER", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 2636, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.CDLUNIQUE3RIVER", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 2638, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 2638, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 2638, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 2638, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_172CDLUNIQUE3RIVER(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_194FLOOR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_172CDLUNIQUE3RIVER(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -21097,53 +24765,79 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_194FLOOR(CYTHON_UNUSED PyObject *__pyx
   TA_RetCode __pyx_v_retCode;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  PyArrayObject *__pyx_v_outreal = 0;
+  PyArrayObject *__pyx_v_outinteger = 0;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  npy_int __pyx_t_2;
-  __Pyx_RefNannySetupContext("FLOOR", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_real);
+  npy_intp __pyx_t_2;
+  npy_int __pyx_t_3;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("CDLUNIQUE3RIVER", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_open);
+  __Pyx_INCREF((PyObject *)__pyx_v_high);
+  __Pyx_INCREF((PyObject *)__pyx_v_low);
+  __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2987, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2655, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2656, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_v_real->data)); if (unlikely(__pyx_t_2 == ((npy_int)-1))) __PYX_ERR(2, 2989, __pyx_L1_error)
-  __pyx_v_begidx = __pyx_t_2;
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2657, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
+
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2658, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
+
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 2659, __pyx_L1_error)
+  __pyx_v_length = __pyx_t_2;
+
+  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 2660, __pyx_L1_error)
+  __pyx_v_begidx = __pyx_t_3;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_FLOOR_Lookback());
+  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLUNIQUE3RIVER_Lookback());
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2992, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2663, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
+  __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_FLOOR(0, __pyx_v_endidx, (((double *)__pyx_v_real->data) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_v_outreal->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_CDLUNIQUE3RIVER(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_FLOOR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2994, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLUNIQUE3RIVER, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2665, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outreal));
-  __pyx_r = ((PyObject *)__pyx_v_outreal);
+  __Pyx_INCREF((PyObject *)__pyx_v_outinteger);
+  __pyx_r = ((PyObject *)__pyx_v_outinteger);
   goto __pyx_L0;
 
 
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.FLOOR", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.CDLUNIQUE3RIVER", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
-  __Pyx_XDECREF((PyObject *)__pyx_v_real);
+  __Pyx_XDECREF((PyObject *)__pyx_v_outinteger);
+  __Pyx_XDECREF((PyObject *)__pyx_v_open);
+  __Pyx_XDECREF((PyObject *)__pyx_v_high);
+  __Pyx_XDECREF((PyObject *)__pyx_v_low);
+  __Pyx_XDECREF((PyObject *)__pyx_v_close);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -21151,26 +24845,129 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_194FLOOR(CYTHON_UNUSED PyObject *__pyx
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_197HT_DCPERIOD(PyObject *__pyx_self, PyObject *__pyx_v_real); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_196HT_DCPERIOD[] = " HT_DCPERIOD(real)\n\n    Hilbert Transform - Dominant Cycle Period (Cycle Indicators)\n\n    Inputs:\n        real: (any ndarray)\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_197HT_DCPERIOD = {"HT_DCPERIOD", (PyCFunction)__pyx_pw_5talib_7_ta_lib_197HT_DCPERIOD, METH_O, __pyx_doc_5talib_7_ta_lib_196HT_DCPERIOD};
-static PyObject *__pyx_pw_5talib_7_ta_lib_197HT_DCPERIOD(PyObject *__pyx_self, PyObject *__pyx_v_real) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_175CDLUPSIDEGAP2CROWS(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_174CDLUPSIDEGAP2CROWS, "CDLUPSIDEGAP2CROWS(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLUPSIDEGAP2CROWS(open, high, low, close)\n\nUpside Gap Two Crows (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_175CDLUPSIDEGAP2CROWS = {"CDLUPSIDEGAP2CROWS", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_175CDLUPSIDEGAP2CROWS, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_174CDLUPSIDEGAP2CROWS};
+static PyObject *__pyx_pw_5talib_7_ta_lib_175CDLUPSIDEGAP2CROWS(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_open = 0;
+  PyArrayObject *__pyx_v_high = 0;
+  PyArrayObject *__pyx_v_low = 0;
+  PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("HT_DCPERIOD (wrapper)", 0);
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(2, 2999, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_196HT_DCPERIOD(__pyx_self, ((PyArrayObject *)__pyx_v_real));
+  __Pyx_RefNannySetupContext("CDLUPSIDEGAP2CROWS (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 2668, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 2668, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 2668, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2668, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2668, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLUPSIDEGAP2CROWS", 0) < (0)) __PYX_ERR(4, 2668, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLUPSIDEGAP2CROWS", 1, 4, 4, i); __PYX_ERR(4, 2668, __pyx_L3_error) }
+      }
+    } else if (unlikely(__pyx_nargs != 4)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2668, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2668, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 2668, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 2668, __pyx_L3_error)
+    }
+    __pyx_v_open = ((PyArrayObject *)values[0]);
+    __pyx_v_high = ((PyArrayObject *)values[1]);
+    __pyx_v_low = ((PyArrayObject *)values[2]);
+    __pyx_v_close = ((PyArrayObject *)values[3]);
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("CDLUPSIDEGAP2CROWS", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 2668, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.CDLUPSIDEGAP2CROWS", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 2670, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 2670, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 2670, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 2670, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_174CDLUPSIDEGAP2CROWS(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_196HT_DCPERIOD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_174CDLUPSIDEGAP2CROWS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -21178,53 +24975,79 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_196HT_DCPERIOD(CYTHON_UNUSED PyObject
   TA_RetCode __pyx_v_retCode;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  PyArrayObject *__pyx_v_outreal = 0;
+  PyArrayObject *__pyx_v_outinteger = 0;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  npy_int __pyx_t_2;
-  __Pyx_RefNannySetupContext("HT_DCPERIOD", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_real);
+  npy_intp __pyx_t_2;
+  npy_int __pyx_t_3;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("CDLUPSIDEGAP2CROWS", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_open);
+  __Pyx_INCREF((PyObject *)__pyx_v_high);
+  __Pyx_INCREF((PyObject *)__pyx_v_low);
+  __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3016, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2687, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2688, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_v_real->data)); if (unlikely(__pyx_t_2 == ((npy_int)-1))) __PYX_ERR(2, 3018, __pyx_L1_error)
-  __pyx_v_begidx = __pyx_t_2;
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2689, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
+
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2690, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
+
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 2691, __pyx_L1_error)
+  __pyx_v_length = __pyx_t_2;
+
+  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 2692, __pyx_L1_error)
+  __pyx_v_begidx = __pyx_t_3;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_HT_DCPERIOD_Lookback());
+  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLUPSIDEGAP2CROWS_Lookback());
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3021, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2695, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
+  __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_HT_DCPERIOD(0, __pyx_v_endidx, (((double *)__pyx_v_real->data) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_v_outreal->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_CDLUPSIDEGAP2CROWS(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_HT_DCPERIOD, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3023, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLUPSIDEGAP2CROWS, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2697, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outreal));
-  __pyx_r = ((PyObject *)__pyx_v_outreal);
+  __Pyx_INCREF((PyObject *)__pyx_v_outinteger);
+  __pyx_r = ((PyObject *)__pyx_v_outinteger);
   goto __pyx_L0;
 
 
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.HT_DCPERIOD", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.CDLUPSIDEGAP2CROWS", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
-  __Pyx_XDECREF((PyObject *)__pyx_v_real);
+  __Pyx_XDECREF((PyObject *)__pyx_v_outinteger);
+  __Pyx_XDECREF((PyObject *)__pyx_v_open);
+  __Pyx_XDECREF((PyObject *)__pyx_v_high);
+  __Pyx_XDECREF((PyObject *)__pyx_v_low);
+  __Pyx_XDECREF((PyObject *)__pyx_v_close);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -21232,26 +25055,129 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_196HT_DCPERIOD(CYTHON_UNUSED PyObject
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_199HT_DCPHASE(PyObject *__pyx_self, PyObject *__pyx_v_real); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_198HT_DCPHASE[] = " HT_DCPHASE(real)\n\n    Hilbert Transform - Dominant Cycle Phase (Cycle Indicators)\n\n    Inputs:\n        real: (any ndarray)\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_199HT_DCPHASE = {"HT_DCPHASE", (PyCFunction)__pyx_pw_5talib_7_ta_lib_199HT_DCPHASE, METH_O, __pyx_doc_5talib_7_ta_lib_198HT_DCPHASE};
-static PyObject *__pyx_pw_5talib_7_ta_lib_199HT_DCPHASE(PyObject *__pyx_self, PyObject *__pyx_v_real) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_177CDLXSIDEGAP3METHODS(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_176CDLXSIDEGAP3METHODS, "CDLXSIDEGAP3METHODS(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLXSIDEGAP3METHODS(open, high, low, close)\n\nUpside/Downside Gap Three Methods (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_177CDLXSIDEGAP3METHODS = {"CDLXSIDEGAP3METHODS", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_177CDLXSIDEGAP3METHODS, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_176CDLXSIDEGAP3METHODS};
+static PyObject *__pyx_pw_5talib_7_ta_lib_177CDLXSIDEGAP3METHODS(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_open = 0;
+  PyArrayObject *__pyx_v_high = 0;
+  PyArrayObject *__pyx_v_low = 0;
+  PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("HT_DCPHASE (wrapper)", 0);
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(2, 3028, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_198HT_DCPHASE(__pyx_self, ((PyArrayObject *)__pyx_v_real));
+  __Pyx_RefNannySetupContext("CDLXSIDEGAP3METHODS (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 2700, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 2700, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 2700, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2700, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2700, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CDLXSIDEGAP3METHODS", 0) < (0)) __PYX_ERR(4, 2700, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CDLXSIDEGAP3METHODS", 1, 4, 4, i); __PYX_ERR(4, 2700, __pyx_L3_error) }
+      }
+    } else if (unlikely(__pyx_nargs != 4)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2700, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2700, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 2700, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 2700, __pyx_L3_error)
+    }
+    __pyx_v_open = ((PyArrayObject *)values[0]);
+    __pyx_v_high = ((PyArrayObject *)values[1]);
+    __pyx_v_low = ((PyArrayObject *)values[2]);
+    __pyx_v_close = ((PyArrayObject *)values[3]);
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("CDLXSIDEGAP3METHODS", 1, 4, 4, __pyx_nargs); __PYX_ERR(4, 2700, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.CDLXSIDEGAP3METHODS", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 2702, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 2702, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 2702, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 2702, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_176CDLXSIDEGAP3METHODS(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_198HT_DCPHASE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_176CDLXSIDEGAP3METHODS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -21259,53 +25185,79 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_198HT_DCPHASE(CYTHON_UNUSED PyObject *
   TA_RetCode __pyx_v_retCode;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  PyArrayObject *__pyx_v_outreal = 0;
+  PyArrayObject *__pyx_v_outinteger = 0;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  npy_int __pyx_t_2;
-  __Pyx_RefNannySetupContext("HT_DCPHASE", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_real);
+  npy_intp __pyx_t_2;
+  npy_int __pyx_t_3;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("CDLXSIDEGAP3METHODS", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_open);
+  __Pyx_INCREF((PyObject *)__pyx_v_high);
+  __Pyx_INCREF((PyObject *)__pyx_v_low);
+  __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3045, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2719, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2720, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_v_real->data)); if (unlikely(__pyx_t_2 == ((npy_int)-1))) __PYX_ERR(2, 3047, __pyx_L1_error)
-  __pyx_v_begidx = __pyx_t_2;
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2721, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
+
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2722, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
+
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 2723, __pyx_L1_error)
+  __pyx_v_length = __pyx_t_2;
+
+  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 2724, __pyx_L1_error)
+  __pyx_v_begidx = __pyx_t_3;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_HT_DCPHASE_Lookback());
+  __pyx_v_lookback = (__pyx_v_begidx + TA_CDLXSIDEGAP3METHODS_Lookback());
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3050, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2727, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
+  __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_HT_DCPHASE(0, __pyx_v_endidx, (((double *)__pyx_v_real->data) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_v_outreal->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_CDLXSIDEGAP3METHODS(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_HT_DCPHASE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3052, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLXSIDEGAP3METHODS, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2729, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outreal));
-  __pyx_r = ((PyObject *)__pyx_v_outreal);
+  __Pyx_INCREF((PyObject *)__pyx_v_outinteger);
+  __pyx_r = ((PyObject *)__pyx_v_outinteger);
   goto __pyx_L0;
 
 
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.HT_DCPHASE", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.CDLXSIDEGAP3METHODS", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
-  __Pyx_XDECREF((PyObject *)__pyx_v_real);
+  __Pyx_XDECREF((PyObject *)__pyx_v_outinteger);
+  __Pyx_XDECREF((PyObject *)__pyx_v_open);
+  __Pyx_XDECREF((PyObject *)__pyx_v_high);
+  __Pyx_XDECREF((PyObject *)__pyx_v_low);
+  __Pyx_XDECREF((PyObject *)__pyx_v_close);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -21313,26 +25265,102 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_198HT_DCPHASE(CYTHON_UNUSED PyObject *
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_201HT_PHASOR(PyObject *__pyx_self, PyObject *__pyx_v_real); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_200HT_PHASOR[] = " HT_PHASOR(real)\n\n    Hilbert Transform - Phasor Components (Cycle Indicators)\n\n    Inputs:\n        real: (any ndarray)\n    Outputs:\n        inphase\n        quadrature\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_201HT_PHASOR = {"HT_PHASOR", (PyCFunction)__pyx_pw_5talib_7_ta_lib_201HT_PHASOR, METH_O, __pyx_doc_5talib_7_ta_lib_200HT_PHASOR};
-static PyObject *__pyx_pw_5talib_7_ta_lib_201HT_PHASOR(PyObject *__pyx_self, PyObject *__pyx_v_real) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_179CEIL(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_178CEIL, "CEIL(ndarray real)\n\nCEIL(real)\n\nVector Ceil (Math Transform)\n\nInputs:\n    real: (any ndarray)\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_179CEIL = {"CEIL", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_179CEIL, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_178CEIL};
+static PyObject *__pyx_pw_5talib_7_ta_lib_179CEIL(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_real = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("HT_PHASOR (wrapper)", 0);
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(2, 3057, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_200HT_PHASOR(__pyx_self, ((PyArrayObject *)__pyx_v_real));
+  __Pyx_RefNannySetupContext("CEIL (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 2732, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2732, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CEIL", 0) < (0)) __PYX_ERR(4, 2732, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CEIL", 1, 1, 1, i); __PYX_ERR(4, 2732, __pyx_L3_error) }
+      }
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2732, __pyx_L3_error)
+    }
+    __pyx_v_real = ((PyArrayObject *)values[0]);
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("CEIL", 1, 1, 1, __pyx_nargs); __PYX_ERR(4, 2732, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.CEIL", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 2734, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_178CEIL(__pyx_self, __pyx_v_real);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_200HT_PHASOR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_178CEIL(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -21340,67 +25368,55 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_200HT_PHASOR(CYTHON_UNUSED PyObject *_
   TA_RetCode __pyx_v_retCode;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  PyArrayObject *__pyx_v_outinphase = 0;
-  PyArrayObject *__pyx_v_outquadrature = 0;
+  PyArrayObject *__pyx_v_outreal = 0;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_int __pyx_t_2;
-  __Pyx_RefNannySetupContext("HT_PHASOR", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("CEIL", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3076, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2751, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_v_real->data)); if (unlikely(__pyx_t_2 == ((npy_int)-1))) __PYX_ERR(2, 3078, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 2753, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_2;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_HT_PHASOR_Lookback());
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3081, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_v_outinphase = ((PyArrayObject *)__pyx_t_1);
-  __pyx_t_1 = 0;
+  __pyx_v_lookback = (__pyx_v_begidx + TA_CEIL_Lookback());
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3082, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2756, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_v_outquadrature = ((PyArrayObject *)__pyx_t_1);
+  __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_HT_PHASOR(0, __pyx_v_endidx, (((double *)__pyx_v_real->data) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_v_outinphase->data) + __pyx_v_lookback), (((double *)__pyx_v_outquadrature->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_CEIL(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_HT_PHASOR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3084, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CEIL, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2758, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3085, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outinphase));
-  __Pyx_GIVEREF(((PyObject *)__pyx_v_outinphase));
-  PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_outinphase));
-  __Pyx_INCREF(((PyObject *)__pyx_v_outquadrature));
-  __Pyx_GIVEREF(((PyObject *)__pyx_v_outquadrature));
-  PyTuple_SET_ITEM(__pyx_t_1, 1, ((PyObject *)__pyx_v_outquadrature));
-  __pyx_r = __pyx_t_1;
-  __pyx_t_1 = 0;
+  __Pyx_INCREF((PyObject *)__pyx_v_outreal);
+  __pyx_r = ((PyObject *)__pyx_v_outreal);
   goto __pyx_L0;
 
 
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.HT_PHASOR", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.CEIL", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_outinphase);
-  __Pyx_XDECREF((PyObject *)__pyx_v_outquadrature);
+  __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
   __Pyx_XDECREF((PyObject *)__pyx_v_real);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
@@ -21409,26 +25425,119 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_200HT_PHASOR(CYTHON_UNUSED PyObject *_
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_203HT_SINE(PyObject *__pyx_self, PyObject *__pyx_v_real); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_202HT_SINE[] = " HT_SINE(real)\n\n    Hilbert Transform - SineWave (Cycle Indicators)\n\n    Inputs:\n        real: (any ndarray)\n    Outputs:\n        sine\n        leadsine\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_203HT_SINE = {"HT_SINE", (PyCFunction)__pyx_pw_5talib_7_ta_lib_203HT_SINE, METH_O, __pyx_doc_5talib_7_ta_lib_202HT_SINE};
-static PyObject *__pyx_pw_5talib_7_ta_lib_203HT_SINE(PyObject *__pyx_self, PyObject *__pyx_v_real) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_181CMO(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_180CMO, "CMO(ndarray real, int timeperiod=-0x80000000)\n\nCMO(real[, timeperiod=?])\n\nChande Momentum Oscillator (Momentum Indicators)\n\nInputs:\n    real: (any ndarray)\nParameters:\n    timeperiod: 14\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_181CMO = {"CMO", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_181CMO, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_180CMO};
+static PyObject *__pyx_pw_5talib_7_ta_lib_181CMO(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_real = 0;
+  int __pyx_v_timeperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("HT_SINE (wrapper)", 0);
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(2, 3089, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_202HT_SINE(__pyx_self, ((PyArrayObject *)__pyx_v_real));
+  __Pyx_RefNannySetupContext("CMO (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 2761, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2761, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2761, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CMO", 0) < (0)) __PYX_ERR(4, 2761, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CMO", 0, 1, 2, i); __PYX_ERR(4, 2761, __pyx_L3_error) }
+      }
+    } else {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2761, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2761, __pyx_L3_error)
+        break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+    }
+    __pyx_v_real = ((PyArrayObject *)values[0]);
+    if (values[1]) {
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 2763, __pyx_L3_error)
+    } else {
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
+    }
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("CMO", 0, 1, 2, __pyx_nargs); __PYX_ERR(4, 2761, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.CMO", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 2763, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_180CMO(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_202HT_SINE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_180CMO(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -21436,67 +25545,55 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_202HT_SINE(CYTHON_UNUSED PyObject *__p
   TA_RetCode __pyx_v_retCode;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  PyArrayObject *__pyx_v_outsine = 0;
-  PyArrayObject *__pyx_v_outleadsine = 0;
+  PyArrayObject *__pyx_v_outreal = 0;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_int __pyx_t_2;
-  __Pyx_RefNannySetupContext("HT_SINE", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("CMO", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3108, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2782, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_v_real->data)); if (unlikely(__pyx_t_2 == ((npy_int)-1))) __PYX_ERR(2, 3110, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 2784, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_2;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_HT_SINE_Lookback());
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3113, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_v_outsine = ((PyArrayObject *)__pyx_t_1);
-  __pyx_t_1 = 0;
+  __pyx_v_lookback = (__pyx_v_begidx + TA_CMO_Lookback(__pyx_v_timeperiod));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3114, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2787, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_v_outleadsine = ((PyArrayObject *)__pyx_t_1);
+  __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_HT_SINE(0, __pyx_v_endidx, (((double *)__pyx_v_real->data) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_v_outsine->data) + __pyx_v_lookback), (((double *)__pyx_v_outleadsine->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_CMO(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_HT_SINE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3116, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CMO, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2789, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3117, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outsine));
-  __Pyx_GIVEREF(((PyObject *)__pyx_v_outsine));
-  PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_outsine));
-  __Pyx_INCREF(((PyObject *)__pyx_v_outleadsine));
-  __Pyx_GIVEREF(((PyObject *)__pyx_v_outleadsine));
-  PyTuple_SET_ITEM(__pyx_t_1, 1, ((PyObject *)__pyx_v_outleadsine));
-  __pyx_r = __pyx_t_1;
-  __pyx_t_1 = 0;
+  __Pyx_INCREF((PyObject *)__pyx_v_outreal);
+  __pyx_r = ((PyObject *)__pyx_v_outreal);
   goto __pyx_L0;
 
 
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.HT_SINE", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.CMO", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_outsine);
-  __Pyx_XDECREF((PyObject *)__pyx_v_outleadsine);
+  __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
   __Pyx_XDECREF((PyObject *)__pyx_v_real);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
@@ -21505,26 +25602,128 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_202HT_SINE(CYTHON_UNUSED PyObject *__p
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_205HT_TRENDLINE(PyObject *__pyx_self, PyObject *__pyx_v_real); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_204HT_TRENDLINE[] = " HT_TRENDLINE(real)\n\n    Hilbert Transform - Instantaneous Trendline (Overlap Studies)\n\n    Inputs:\n        real: (any ndarray)\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_205HT_TRENDLINE = {"HT_TRENDLINE", (PyCFunction)__pyx_pw_5talib_7_ta_lib_205HT_TRENDLINE, METH_O, __pyx_doc_5talib_7_ta_lib_204HT_TRENDLINE};
-static PyObject *__pyx_pw_5talib_7_ta_lib_205HT_TRENDLINE(PyObject *__pyx_self, PyObject *__pyx_v_real) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_183CORREL(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_182CORREL, "CORREL(ndarray real0, ndarray real1, int timeperiod=-0x80000000)\n\nCORREL(real0, real1[, timeperiod=?])\n\nPearson's Correlation Coefficient (r) (Statistic Functions)\n\nInputs:\n    real0: (any ndarray)\n    real1: (any ndarray)\nParameters:\n    timeperiod: 30\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_183CORREL = {"CORREL", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_183CORREL, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_182CORREL};
+static PyObject *__pyx_pw_5talib_7_ta_lib_183CORREL(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_real0 = 0;
+  PyArrayObject *__pyx_v_real1 = 0;
+  int __pyx_v_timeperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[3] = {0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("HT_TRENDLINE (wrapper)", 0);
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(2, 3121, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_204HT_TRENDLINE(__pyx_self, ((PyArrayObject *)__pyx_v_real));
+  __Pyx_RefNannySetupContext("CORREL (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real0,&__pyx_mstate_global->__pyx_n_u_real1,&__pyx_mstate_global->__pyx_n_u_timeperiod,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 2792, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 2792, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2792, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2792, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "CORREL", 0) < (0)) __PYX_ERR(4, 2792, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("CORREL", 0, 2, 3, i); __PYX_ERR(4, 2792, __pyx_L3_error) }
+      }
+    } else {
+      switch (__pyx_nargs) {
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 2792, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2792, __pyx_L3_error)
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2792, __pyx_L3_error)
+        break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+    }
+    __pyx_v_real0 = ((PyArrayObject *)values[0]);
+    __pyx_v_real1 = ((PyArrayObject *)values[1]);
+    if (values[2]) {
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[2]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 2794, __pyx_L3_error)
+    } else {
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
+    }
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("CORREL", 0, 2, 3, __pyx_nargs); __PYX_ERR(4, 2792, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.CORREL", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real0), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real0", 0))) __PYX_ERR(4, 2794, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real1), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real1", 0))) __PYX_ERR(4, 2794, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_182CORREL(__pyx_self, __pyx_v_real0, __pyx_v_real1, __pyx_v_timeperiod);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_204HT_TRENDLINE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_182CORREL(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real0, PyArrayObject *__pyx_v_real1, int __pyx_v_timeperiod) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -21536,37 +25735,48 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_204HT_TRENDLINE(CYTHON_UNUSED PyObject
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  npy_int __pyx_t_2;
-  __Pyx_RefNannySetupContext("HT_TRENDLINE", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_real);
+  npy_intp __pyx_t_2;
+  npy_int __pyx_t_3;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("CORREL", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_real0);
+  __Pyx_INCREF((PyObject *)__pyx_v_real1);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3138, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2814, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_real0, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2815, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_real1, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_v_real->data)); if (unlikely(__pyx_t_2 == ((npy_int)-1))) __PYX_ERR(2, 3140, __pyx_L1_error)
-  __pyx_v_begidx = __pyx_t_2;
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_real0, __pyx_v_real1); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 2816, __pyx_L1_error)
+  __pyx_v_length = __pyx_t_2;
+
+  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx2(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real0)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real1))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 2817, __pyx_L1_error)
+  __pyx_v_begidx = __pyx_t_3;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_HT_TRENDLINE_Lookback());
+  __pyx_v_lookback = (__pyx_v_begidx + TA_CORREL_Lookback(__pyx_v_timeperiod));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3143, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2820, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_HT_TRENDLINE(0, __pyx_v_endidx, (((double *)__pyx_v_real->data) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_v_outreal->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_CORREL(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real0)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real1)) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_HT_TRENDLINE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3145, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CORREL, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2822, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outreal));
+  __Pyx_INCREF((PyObject *)__pyx_v_outreal);
   __pyx_r = ((PyObject *)__pyx_v_outreal);
   goto __pyx_L0;
 
@@ -21574,11 +25784,12 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_204HT_TRENDLINE(CYTHON_UNUSED PyObject
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.HT_TRENDLINE", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.CORREL", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
-  __Pyx_XDECREF((PyObject *)__pyx_v_real);
+  __Pyx_XDECREF((PyObject *)__pyx_v_real0);
+  __Pyx_XDECREF((PyObject *)__pyx_v_real1);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -21586,26 +25797,102 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_204HT_TRENDLINE(CYTHON_UNUSED PyObject
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_207HT_TRENDMODE(PyObject *__pyx_self, PyObject *__pyx_v_real); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_206HT_TRENDMODE[] = " HT_TRENDMODE(real)\n\n    Hilbert Transform - Trend vs Cycle Mode (Cycle Indicators)\n\n    Inputs:\n        real: (any ndarray)\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_207HT_TRENDMODE = {"HT_TRENDMODE", (PyCFunction)__pyx_pw_5talib_7_ta_lib_207HT_TRENDMODE, METH_O, __pyx_doc_5talib_7_ta_lib_206HT_TRENDMODE};
-static PyObject *__pyx_pw_5talib_7_ta_lib_207HT_TRENDMODE(PyObject *__pyx_self, PyObject *__pyx_v_real) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_185COS(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_184COS, "COS(ndarray real)\n\nCOS(real)\n\nVector Trigonometric Cos (Math Transform)\n\nInputs:\n    real: (any ndarray)\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_185COS = {"COS", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_185COS, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_184COS};
+static PyObject *__pyx_pw_5talib_7_ta_lib_185COS(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_real = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("HT_TRENDMODE (wrapper)", 0);
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(2, 3150, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_206HT_TRENDMODE(__pyx_self, ((PyArrayObject *)__pyx_v_real));
+  __Pyx_RefNannySetupContext("COS (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 2825, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2825, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "COS", 0) < (0)) __PYX_ERR(4, 2825, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("COS", 1, 1, 1, i); __PYX_ERR(4, 2825, __pyx_L3_error) }
+      }
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2825, __pyx_L3_error)
+    }
+    __pyx_v_real = ((PyArrayObject *)values[0]);
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("COS", 1, 1, 1, __pyx_nargs); __PYX_ERR(4, 2825, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.COS", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 2827, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_184COS(__pyx_self, __pyx_v_real);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_206HT_TRENDMODE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_184COS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -21613,52 +25900,55 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_206HT_TRENDMODE(CYTHON_UNUSED PyObject
   TA_RetCode __pyx_v_retCode;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  PyArrayObject *__pyx_v_outinteger = 0;
+  PyArrayObject *__pyx_v_outreal = 0;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_int __pyx_t_2;
-  __Pyx_RefNannySetupContext("HT_TRENDMODE", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("COS", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3167, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2844, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_v_real->data)); if (unlikely(__pyx_t_2 == ((npy_int)-1))) __PYX_ERR(2, 3169, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 2846, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_2;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_HT_TRENDMODE_Lookback());
+  __pyx_v_lookback = (__pyx_v_begidx + TA_COS_Lookback());
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3172, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2849, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1);
+  __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_HT_TRENDMODE(0, __pyx_v_endidx, (((double *)__pyx_v_real->data) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_v_outinteger->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_COS(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_HT_TRENDMODE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3174, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_COS, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2851, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outinteger));
-  __pyx_r = ((PyObject *)__pyx_v_outinteger);
+  __Pyx_INCREF((PyObject *)__pyx_v_outreal);
+  __pyx_r = ((PyObject *)__pyx_v_outreal);
   goto __pyx_L0;
 
 
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.HT_TRENDMODE", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.COS", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_outinteger);
+  __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
   __Pyx_XDECREF((PyObject *)__pyx_v_real);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
@@ -21667,81 +25957,102 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_206HT_TRENDMODE(CYTHON_UNUSED PyObject
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_209KAMA(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_208KAMA[] = " KAMA(real[, timeperiod=?])\n\n    Kaufman Adaptive Moving Average (Overlap Studies)\n\n    Inputs:\n        real: (any ndarray)\n    Parameters:\n        timeperiod: 30\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_209KAMA = {"KAMA", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_209KAMA, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_208KAMA};
-static PyObject *__pyx_pw_5talib_7_ta_lib_209KAMA(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_187COSH(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_186COSH, "COSH(ndarray real)\n\nCOSH(real)\n\nVector Trigonometric Cosh (Math Transform)\n\nInputs:\n    real: (any ndarray)\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_187COSH = {"COSH", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_187COSH, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_186COSH};
+static PyObject *__pyx_pw_5talib_7_ta_lib_187COSH(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_real = 0;
-  int __pyx_v_timeperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("KAMA (wrapper)", 0);
+  __Pyx_RefNannySetupContext("COSH (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,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);
-        CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 2854, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2854, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod);
-          if (value) { values[1] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "KAMA") < 0)) __PYX_ERR(2, 3179, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "COSH", 0) < (0)) __PYX_ERR(4, 2854, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("COSH", 1, 1, 1, i); __PYX_ERR(4, 2854, __pyx_L3_error) }
       }
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-        break;
-        default: goto __pyx_L5_argtuple_error;
-      }
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2854, __pyx_L3_error)
     }
     __pyx_v_real = ((PyArrayObject *)values[0]);
-    if (values[1]) {
-      __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 3179, __pyx_L3_error)
-    } else {
-      __pyx_v_timeperiod = ((int)-2147483648);
-    }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("KAMA", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 3179, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("COSH", 1, 1, 1, __pyx_nargs); __PYX_ERR(4, 2854, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.KAMA", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.COSH", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(2, 3179, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_208KAMA(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 2856, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_186COSH(__pyx_self, __pyx_v_real);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_208KAMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_186COSH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -21754,36 +26065,39 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_208KAMA(CYTHON_UNUSED PyObject *__pyx_
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_int __pyx_t_2;
-  __Pyx_RefNannySetupContext("KAMA", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("COSH", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3198, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2873, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_v_real->data)); if (unlikely(__pyx_t_2 == ((npy_int)-1))) __PYX_ERR(2, 3200, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 2875, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_2;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_KAMA_Lookback(__pyx_v_timeperiod));
+  __pyx_v_lookback = (__pyx_v_begidx + TA_COSH_Lookback());
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3203, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2878, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_KAMA(0, __pyx_v_endidx, (((double *)__pyx_v_real->data) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_v_outreal->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_COSH(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_KAMA, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3205, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_COSH, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2880, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outreal));
+  __Pyx_INCREF((PyObject *)__pyx_v_outreal);
   __pyx_r = ((PyObject *)__pyx_v_outreal);
   goto __pyx_L0;
 
@@ -21791,7 +26105,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_208KAMA(CYTHON_UNUSED PyObject *__pyx_
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.KAMA", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.COSH", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
@@ -21803,81 +26117,119 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_208KAMA(CYTHON_UNUSED PyObject *__pyx_
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_211LINEARREG(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_210LINEARREG[] = " LINEARREG(real[, timeperiod=?])\n\n    Linear Regression (Statistic Functions)\n\n    Inputs:\n        real: (any ndarray)\n    Parameters:\n        timeperiod: 14\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_211LINEARREG = {"LINEARREG", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_211LINEARREG, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_210LINEARREG};
-static PyObject *__pyx_pw_5talib_7_ta_lib_211LINEARREG(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_189DEMA(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_188DEMA, "DEMA(ndarray real, int timeperiod=-0x80000000)\n\nDEMA(real[, timeperiod=?])\n\nDouble Exponential Moving Average (Overlap Studies)\n\nInputs:\n    real: (any ndarray)\nParameters:\n    timeperiod: 30\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_189DEMA = {"DEMA", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_189DEMA, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_188DEMA};
+static PyObject *__pyx_pw_5talib_7_ta_lib_189DEMA(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_real = 0;
   int __pyx_v_timeperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("LINEARREG (wrapper)", 0);
+  __Pyx_RefNannySetupContext("DEMA (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,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);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 2883, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2883, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2883, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod);
-          if (value) { values[1] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "LINEARREG") < 0)) __PYX_ERR(2, 3210, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "DEMA", 0) < (0)) __PYX_ERR(4, 2883, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("DEMA", 0, 1, 2, i); __PYX_ERR(4, 2883, __pyx_L3_error) }
       }
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2883, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2883, __pyx_L3_error)
         break;
         default: goto __pyx_L5_argtuple_error;
       }
     }
     __pyx_v_real = ((PyArrayObject *)values[0]);
     if (values[1]) {
-      __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 3210, __pyx_L3_error)
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 2885, __pyx_L3_error)
     } else {
-      __pyx_v_timeperiod = ((int)-2147483648);
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
     }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("LINEARREG", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 3210, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("DEMA", 0, 1, 2, __pyx_nargs); __PYX_ERR(4, 2883, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.LINEARREG", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.DEMA", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(2, 3210, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_210LINEARREG(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 2885, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_188DEMA(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_210LINEARREG(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_188DEMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -21890,36 +26242,39 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_210LINEARREG(CYTHON_UNUSED PyObject *_
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_int __pyx_t_2;
-  __Pyx_RefNannySetupContext("LINEARREG", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("DEMA", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3229, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2904, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_v_real->data)); if (unlikely(__pyx_t_2 == ((npy_int)-1))) __PYX_ERR(2, 3231, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 2906, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_2;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_LINEARREG_Lookback(__pyx_v_timeperiod));
+  __pyx_v_lookback = (__pyx_v_begidx + TA_DEMA_Lookback(__pyx_v_timeperiod));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3234, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2909, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_LINEARREG(0, __pyx_v_endidx, (((double *)__pyx_v_real->data) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_v_outreal->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_DEMA(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_LINEARREG, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3236, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_DEMA, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2911, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outreal));
+  __Pyx_INCREF((PyObject *)__pyx_v_outreal);
   __pyx_r = ((PyObject *)__pyx_v_outreal);
   goto __pyx_L0;
 
@@ -21927,7 +26282,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_210LINEARREG(CYTHON_UNUSED PyObject *_
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.LINEARREG", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.DEMA", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
@@ -21939,81 +26294,111 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_210LINEARREG(CYTHON_UNUSED PyObject *_
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_213LINEARREG_ANGLE(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_212LINEARREG_ANGLE[] = " LINEARREG_ANGLE(real[, timeperiod=?])\n\n    Linear Regression Angle (Statistic Functions)\n\n    Inputs:\n        real: (any ndarray)\n    Parameters:\n        timeperiod: 14\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_213LINEARREG_ANGLE = {"LINEARREG_ANGLE", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_213LINEARREG_ANGLE, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_212LINEARREG_ANGLE};
-static PyObject *__pyx_pw_5talib_7_ta_lib_213LINEARREG_ANGLE(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_real = 0;
-  int __pyx_v_timeperiod;
+static PyObject *__pyx_pw_5talib_7_ta_lib_191DIV(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_190DIV, "DIV(ndarray real0, ndarray real1)\n\nDIV(real0, real1)\n\nVector Arithmetic Div (Math Operators)\n\nInputs:\n    real0: (any ndarray)\n    real1: (any ndarray)\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_191DIV = {"DIV", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_191DIV, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_190DIV};
+static PyObject *__pyx_pw_5talib_7_ta_lib_191DIV(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_real0 = 0;
+  PyArrayObject *__pyx_v_real1 = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("LINEARREG_ANGLE (wrapper)", 0);
+  __Pyx_RefNannySetupContext("DIV (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,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);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real0,&__pyx_mstate_global->__pyx_n_u_real1,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 2914, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2914, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2914, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod);
-          if (value) { values[1] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "LINEARREG_ANGLE") < 0)) __PYX_ERR(2, 3241, __pyx_L3_error)
-      }
-    } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-        break;
-        default: goto __pyx_L5_argtuple_error;
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "DIV", 0) < (0)) __PYX_ERR(4, 2914, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("DIV", 1, 2, 2, i); __PYX_ERR(4, 2914, __pyx_L3_error) }
       }
-    }
-    __pyx_v_real = ((PyArrayObject *)values[0]);
-    if (values[1]) {
-      __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 3241, __pyx_L3_error)
+    } else if (unlikely(__pyx_nargs != 2)) {
+      goto __pyx_L5_argtuple_error;
     } else {
-      __pyx_v_timeperiod = ((int)-2147483648);
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2914, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2914, __pyx_L3_error)
     }
+    __pyx_v_real0 = ((PyArrayObject *)values[0]);
+    __pyx_v_real1 = ((PyArrayObject *)values[1]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("LINEARREG_ANGLE", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 3241, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("DIV", 1, 2, 2, __pyx_nargs); __PYX_ERR(4, 2914, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.LINEARREG_ANGLE", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.DIV", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(2, 3241, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_212LINEARREG_ANGLE(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real0), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real0", 0))) __PYX_ERR(4, 2916, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real1), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real1", 0))) __PYX_ERR(4, 2916, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_190DIV(__pyx_self, __pyx_v_real0, __pyx_v_real1);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_212LINEARREG_ANGLE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_190DIV(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real0, PyArrayObject *__pyx_v_real1) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -22025,37 +26410,48 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_212LINEARREG_ANGLE(CYTHON_UNUSED PyObj
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  npy_int __pyx_t_2;
-  __Pyx_RefNannySetupContext("LINEARREG_ANGLE", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_real);
+  npy_intp __pyx_t_2;
+  npy_int __pyx_t_3;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("DIV", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_real0);
+  __Pyx_INCREF((PyObject *)__pyx_v_real1);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3260, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2934, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_real0, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
+
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2935, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_real1, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_real0, __pyx_v_real1); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 2936, __pyx_L1_error)
+  __pyx_v_length = __pyx_t_2;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_v_real->data)); if (unlikely(__pyx_t_2 == ((npy_int)-1))) __PYX_ERR(2, 3262, __pyx_L1_error)
-  __pyx_v_begidx = __pyx_t_2;
+  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx2(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real0)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real1))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 2937, __pyx_L1_error)
+  __pyx_v_begidx = __pyx_t_3;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_LINEARREG_ANGLE_Lookback(__pyx_v_timeperiod));
+  __pyx_v_lookback = (__pyx_v_begidx + TA_DIV_Lookback());
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3265, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2940, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_LINEARREG_ANGLE(0, __pyx_v_endidx, (((double *)__pyx_v_real->data) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_v_outreal->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_DIV(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real0)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real1)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_LINEARREG_ANGLE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3267, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_DIV, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2942, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outreal));
+  __Pyx_INCREF((PyObject *)__pyx_v_outreal);
   __pyx_r = ((PyObject *)__pyx_v_outreal);
   goto __pyx_L0;
 
@@ -22063,11 +26459,12 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_212LINEARREG_ANGLE(CYTHON_UNUSED PyObj
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.LINEARREG_ANGLE", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.DIV", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
-  __Pyx_XDECREF((PyObject *)__pyx_v_real);
+  __Pyx_XDECREF((PyObject *)__pyx_v_real0);
+  __Pyx_XDECREF((PyObject *)__pyx_v_real1);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -22075,81 +26472,137 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_212LINEARREG_ANGLE(CYTHON_UNUSED PyObj
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_215LINEARREG_INTERCEPT(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_214LINEARREG_INTERCEPT[] = " LINEARREG_INTERCEPT(real[, timeperiod=?])\n\n    Linear Regression Intercept (Statistic Functions)\n\n    Inputs:\n        real: (any ndarray)\n    Parameters:\n        timeperiod: 14\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_215LINEARREG_INTERCEPT = {"LINEARREG_INTERCEPT", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_215LINEARREG_INTERCEPT, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_214LINEARREG_INTERCEPT};
-static PyObject *__pyx_pw_5talib_7_ta_lib_215LINEARREG_INTERCEPT(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_real = 0;
+static PyObject *__pyx_pw_5talib_7_ta_lib_193DX(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_192DX, "DX(ndarray high, ndarray low, ndarray close, int timeperiod=-0x80000000)\n\nDX(high, low, close[, timeperiod=?])\n\nDirectional Movement Index (Momentum Indicators)\n\nInputs:\n    prices: ['high', 'low', 'close']\nParameters:\n    timeperiod: 14\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_193DX = {"DX", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_193DX, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_192DX};
+static PyObject *__pyx_pw_5talib_7_ta_lib_193DX(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_high = 0;
+  PyArrayObject *__pyx_v_low = 0;
+  PyArrayObject *__pyx_v_close = 0;
   int __pyx_v_timeperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("LINEARREG_INTERCEPT (wrapper)", 0);
+  __Pyx_RefNannySetupContext("DX (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,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);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,&__pyx_mstate_global->__pyx_n_u_timeperiod,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 2945, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 2945, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 2945, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  0: break;
-        default: goto __pyx_L5_argtuple_error;
-      }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2945, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  1:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod);
-          if (value) { values[1] = value; kw_args--; }
-        }
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2945, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
       }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "LINEARREG_INTERCEPT") < 0)) __PYX_ERR(2, 3272, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "DX", 0) < (0)) __PYX_ERR(4, 2945, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 3; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("DX", 0, 3, 4, i); __PYX_ERR(4, 2945, __pyx_L3_error) }
       }
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 2945, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 2945, __pyx_L3_error)
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2945, __pyx_L3_error)
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2945, __pyx_L3_error)
         break;
         default: goto __pyx_L5_argtuple_error;
       }
     }
-    __pyx_v_real = ((PyArrayObject *)values[0]);
-    if (values[1]) {
-      __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 3272, __pyx_L3_error)
+    __pyx_v_high = ((PyArrayObject *)values[0]);
+    __pyx_v_low = ((PyArrayObject *)values[1]);
+    __pyx_v_close = ((PyArrayObject *)values[2]);
+    if (values[3]) {
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[3]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 2947, __pyx_L3_error)
     } else {
-      __pyx_v_timeperiod = ((int)-2147483648);
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
     }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("LINEARREG_INTERCEPT", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 3272, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("DX", 0, 3, 4, __pyx_nargs); __PYX_ERR(4, 2945, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.LINEARREG_INTERCEPT", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.DX", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(2, 3272, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_214LINEARREG_INTERCEPT(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 2947, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 2947, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 2947, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_192DX(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_timeperiod);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_214LINEARREG_INTERCEPT(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_192DX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -22161,37 +26614,54 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_214LINEARREG_INTERCEPT(CYTHON_UNUSED P
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  npy_int __pyx_t_2;
-  __Pyx_RefNannySetupContext("LINEARREG_INTERCEPT", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_real);
+  npy_intp __pyx_t_2;
+  npy_int __pyx_t_3;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("DX", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_high);
+  __Pyx_INCREF((PyObject *)__pyx_v_low);
+  __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3291, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2966, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
+
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2967, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
+
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2968, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 2969, __pyx_L1_error)
+  __pyx_v_length = __pyx_t_2;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_v_real->data)); if (unlikely(__pyx_t_2 == ((npy_int)-1))) __PYX_ERR(2, 3293, __pyx_L1_error)
-  __pyx_v_begidx = __pyx_t_2;
+  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx3(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 2970, __pyx_L1_error)
+  __pyx_v_begidx = __pyx_t_3;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_LINEARREG_INTERCEPT_Lookback(__pyx_v_timeperiod));
+  __pyx_v_lookback = (__pyx_v_begidx + TA_DX_Lookback(__pyx_v_timeperiod));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3296, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2973, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_LINEARREG_INTERCEPT(0, __pyx_v_endidx, (((double *)__pyx_v_real->data) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_v_outreal->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_DX(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_LINEARREG_INTERCEPT, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3298, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_DX, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2975, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outreal));
+  __Pyx_INCREF((PyObject *)__pyx_v_outreal);
   __pyx_r = ((PyObject *)__pyx_v_outreal);
   goto __pyx_L0;
 
@@ -22199,11 +26669,13 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_214LINEARREG_INTERCEPT(CYTHON_UNUSED P
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.LINEARREG_INTERCEPT", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.DX", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
-  __Pyx_XDECREF((PyObject *)__pyx_v_real);
+  __Pyx_XDECREF((PyObject *)__pyx_v_high);
+  __Pyx_XDECREF((PyObject *)__pyx_v_low);
+  __Pyx_XDECREF((PyObject *)__pyx_v_close);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -22211,81 +26683,119 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_214LINEARREG_INTERCEPT(CYTHON_UNUSED P
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_217LINEARREG_SLOPE(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_216LINEARREG_SLOPE[] = " LINEARREG_SLOPE(real[, timeperiod=?])\n\n    Linear Regression Slope (Statistic Functions)\n\n    Inputs:\n        real: (any ndarray)\n    Parameters:\n        timeperiod: 14\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_217LINEARREG_SLOPE = {"LINEARREG_SLOPE", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_217LINEARREG_SLOPE, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_216LINEARREG_SLOPE};
-static PyObject *__pyx_pw_5talib_7_ta_lib_217LINEARREG_SLOPE(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_195EMA(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_194EMA, "EMA(ndarray real, int timeperiod=-0x80000000)\n\nEMA(real[, timeperiod=?])\n\nExponential Moving Average (Overlap Studies)\n\nInputs:\n    real: (any ndarray)\nParameters:\n    timeperiod: 30\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_195EMA = {"EMA", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_195EMA, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_194EMA};
+static PyObject *__pyx_pw_5talib_7_ta_lib_195EMA(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_real = 0;
   int __pyx_v_timeperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("LINEARREG_SLOPE (wrapper)", 0);
+  __Pyx_RefNannySetupContext("EMA (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,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);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 2978, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2978, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2978, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod);
-          if (value) { values[1] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "LINEARREG_SLOPE") < 0)) __PYX_ERR(2, 3303, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "EMA", 0) < (0)) __PYX_ERR(4, 2978, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("EMA", 0, 1, 2, i); __PYX_ERR(4, 2978, __pyx_L3_error) }
       }
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 2978, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 2978, __pyx_L3_error)
         break;
         default: goto __pyx_L5_argtuple_error;
       }
     }
     __pyx_v_real = ((PyArrayObject *)values[0]);
     if (values[1]) {
-      __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 3303, __pyx_L3_error)
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 2980, __pyx_L3_error)
     } else {
-      __pyx_v_timeperiod = ((int)-2147483648);
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
     }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("LINEARREG_SLOPE", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 3303, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("EMA", 0, 1, 2, __pyx_nargs); __PYX_ERR(4, 2978, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.LINEARREG_SLOPE", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.EMA", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(2, 3303, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_216LINEARREG_SLOPE(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 2980, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_194EMA(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_216LINEARREG_SLOPE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_194EMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -22298,36 +26808,39 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_216LINEARREG_SLOPE(CYTHON_UNUSED PyObj
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_int __pyx_t_2;
-  __Pyx_RefNannySetupContext("LINEARREG_SLOPE", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("EMA", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3322, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 2999, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_v_real->data)); if (unlikely(__pyx_t_2 == ((npy_int)-1))) __PYX_ERR(2, 3324, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3001, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_2;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_LINEARREG_SLOPE_Lookback(__pyx_v_timeperiod));
+  __pyx_v_lookback = (__pyx_v_begidx + TA_EMA_Lookback(__pyx_v_timeperiod));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3327, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3004, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_LINEARREG_SLOPE(0, __pyx_v_endidx, (((double *)__pyx_v_real->data) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_v_outreal->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_EMA(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_LINEARREG_SLOPE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3329, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_EMA, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3006, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outreal));
+  __Pyx_INCREF((PyObject *)__pyx_v_outreal);
   __pyx_r = ((PyObject *)__pyx_v_outreal);
   goto __pyx_L0;
 
@@ -22335,7 +26848,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_216LINEARREG_SLOPE(CYTHON_UNUSED PyObj
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.LINEARREG_SLOPE", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.EMA", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
@@ -22347,26 +26860,102 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_216LINEARREG_SLOPE(CYTHON_UNUSED PyObj
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_219LN(PyObject *__pyx_self, PyObject *__pyx_v_real); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_218LN[] = " LN(real)\n\n    Vector Log Natural (Math Transform)\n\n    Inputs:\n        real: (any ndarray)\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_219LN = {"LN", (PyCFunction)__pyx_pw_5talib_7_ta_lib_219LN, METH_O, __pyx_doc_5talib_7_ta_lib_218LN};
-static PyObject *__pyx_pw_5talib_7_ta_lib_219LN(PyObject *__pyx_self, PyObject *__pyx_v_real) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_197EXP(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_196EXP, "EXP(ndarray real)\n\nEXP(real)\n\nVector Arithmetic Exp (Math Transform)\n\nInputs:\n    real: (any ndarray)\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_197EXP = {"EXP", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_197EXP, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_196EXP};
+static PyObject *__pyx_pw_5talib_7_ta_lib_197EXP(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_real = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("LN (wrapper)", 0);
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(2, 3334, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_218LN(__pyx_self, ((PyArrayObject *)__pyx_v_real));
+  __Pyx_RefNannySetupContext("EXP (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 3009, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3009, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "EXP", 0) < (0)) __PYX_ERR(4, 3009, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("EXP", 1, 1, 1, i); __PYX_ERR(4, 3009, __pyx_L3_error) }
+      }
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3009, __pyx_L3_error)
+    }
+    __pyx_v_real = ((PyArrayObject *)values[0]);
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("EXP", 1, 1, 1, __pyx_nargs); __PYX_ERR(4, 3009, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.EXP", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 3011, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_196EXP(__pyx_self, __pyx_v_real);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_218LN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_196EXP(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -22379,36 +26968,39 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_218LN(CYTHON_UNUSED PyObject *__pyx_se
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_int __pyx_t_2;
-  __Pyx_RefNannySetupContext("LN", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("EXP", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3351, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3028, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_v_real->data)); if (unlikely(__pyx_t_2 == ((npy_int)-1))) __PYX_ERR(2, 3353, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3030, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_2;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_LN_Lookback());
+  __pyx_v_lookback = (__pyx_v_begidx + TA_EXP_Lookback());
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3356, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3033, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_LN(0, __pyx_v_endidx, (((double *)__pyx_v_real->data) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_v_outreal->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_EXP(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_LN, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3358, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_EXP, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3035, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outreal));
+  __Pyx_INCREF((PyObject *)__pyx_v_outreal);
   __pyx_r = ((PyObject *)__pyx_v_outreal);
   goto __pyx_L0;
 
@@ -22416,7 +27008,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_218LN(CYTHON_UNUSED PyObject *__pyx_se
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.LN", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.EXP", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
@@ -22428,26 +27020,102 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_218LN(CYTHON_UNUSED PyObject *__pyx_se
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_221LOG10(PyObject *__pyx_self, PyObject *__pyx_v_real); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_220LOG10[] = " LOG10(real)\n\n    Vector Log10 (Math Transform)\n\n    Inputs:\n        real: (any ndarray)\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_221LOG10 = {"LOG10", (PyCFunction)__pyx_pw_5talib_7_ta_lib_221LOG10, METH_O, __pyx_doc_5talib_7_ta_lib_220LOG10};
-static PyObject *__pyx_pw_5talib_7_ta_lib_221LOG10(PyObject *__pyx_self, PyObject *__pyx_v_real) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_199FLOOR(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_198FLOOR, "FLOOR(ndarray real)\n\nFLOOR(real)\n\nVector Floor (Math Transform)\n\nInputs:\n    real: (any ndarray)\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_199FLOOR = {"FLOOR", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_199FLOOR, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_198FLOOR};
+static PyObject *__pyx_pw_5talib_7_ta_lib_199FLOOR(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_real = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("LOG10 (wrapper)", 0);
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(2, 3363, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_220LOG10(__pyx_self, ((PyArrayObject *)__pyx_v_real));
+  __Pyx_RefNannySetupContext("FLOOR (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 3038, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3038, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "FLOOR", 0) < (0)) __PYX_ERR(4, 3038, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("FLOOR", 1, 1, 1, i); __PYX_ERR(4, 3038, __pyx_L3_error) }
+      }
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3038, __pyx_L3_error)
+    }
+    __pyx_v_real = ((PyArrayObject *)values[0]);
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("FLOOR", 1, 1, 1, __pyx_nargs); __PYX_ERR(4, 3038, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.FLOOR", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 3040, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_198FLOOR(__pyx_self, __pyx_v_real);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_220LOG10(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_198FLOOR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -22460,36 +27128,39 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_220LOG10(CYTHON_UNUSED PyObject *__pyx
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_int __pyx_t_2;
-  __Pyx_RefNannySetupContext("LOG10", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("FLOOR", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3380, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3057, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_v_real->data)); if (unlikely(__pyx_t_2 == ((npy_int)-1))) __PYX_ERR(2, 3382, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3059, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_2;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_LOG10_Lookback());
+  __pyx_v_lookback = (__pyx_v_begidx + TA_FLOOR_Lookback());
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3385, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3062, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_LOG10(0, __pyx_v_endidx, (((double *)__pyx_v_real->data) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_v_outreal->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_FLOOR(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_LOG10, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3387, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_FLOOR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3064, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outreal));
+  __Pyx_INCREF((PyObject *)__pyx_v_outreal);
   __pyx_r = ((PyObject *)__pyx_v_outreal);
   goto __pyx_L0;
 
@@ -22497,7 +27168,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_220LOG10(CYTHON_UNUSED PyObject *__pyx
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.LOG10", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.FLOOR", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
@@ -22509,97 +27180,102 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_220LOG10(CYTHON_UNUSED PyObject *__pyx
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_223MA(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_222MA[] = " MA(real[, timeperiod=?, matype=?])\n\n    Moving average (Overlap Studies)\n\n    Inputs:\n        real: (any ndarray)\n    Parameters:\n        timeperiod: 30\n        matype: 0 (Simple Moving Average)\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_223MA = {"MA", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_223MA, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_222MA};
-static PyObject *__pyx_pw_5talib_7_ta_lib_223MA(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_201HT_DCPERIOD(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_200HT_DCPERIOD, "HT_DCPERIOD(ndarray real)\n\nHT_DCPERIOD(real)\n\nHilbert Transform - Dominant Cycle Period (Cycle Indicators)\n\nInputs:\n    real: (any ndarray)\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_201HT_DCPERIOD = {"HT_DCPERIOD", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_201HT_DCPERIOD, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_200HT_DCPERIOD};
+static PyObject *__pyx_pw_5talib_7_ta_lib_201HT_DCPERIOD(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_real = 0;
-  int __pyx_v_timeperiod;
-  int __pyx_v_matype;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("MA (wrapper)", 0);
+  __Pyx_RefNannySetupContext("HT_DCPERIOD (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,&__pyx_n_s_matype,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);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 3067, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3067, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod);
-          if (value) { values[1] = value; kw_args--; }
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_matype);
-          if (value) { values[2] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "MA") < 0)) __PYX_ERR(2, 3392, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "HT_DCPERIOD", 0) < (0)) __PYX_ERR(4, 3067, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("HT_DCPERIOD", 1, 1, 1, i); __PYX_ERR(4, 3067, __pyx_L3_error) }
       }
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-        break;
-        default: goto __pyx_L5_argtuple_error;
-      }
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3067, __pyx_L3_error)
     }
     __pyx_v_real = ((PyArrayObject *)values[0]);
-    if (values[1]) {
-      __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 3392, __pyx_L3_error)
-    } else {
-      __pyx_v_timeperiod = ((int)-2147483648);
-    }
-    if (values[2]) {
-      __pyx_v_matype = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_matype == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 3392, __pyx_L3_error)
-    } else {
-      __pyx_v_matype = ((int)0);
-    }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("MA", 0, 1, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 3392, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("HT_DCPERIOD", 1, 1, 1, __pyx_nargs); __PYX_ERR(4, 3067, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.MA", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.HT_DCPERIOD", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(2, 3392, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_222MA(__pyx_self, __pyx_v_real, __pyx_v_timeperiod, __pyx_v_matype);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 3069, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_200HT_DCPERIOD(__pyx_self, __pyx_v_real);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_222MA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod, int __pyx_v_matype) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_200HT_DCPERIOD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -22612,36 +27288,39 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_222MA(CYTHON_UNUSED PyObject *__pyx_se
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_int __pyx_t_2;
-  __Pyx_RefNannySetupContext("MA", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("HT_DCPERIOD", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3412, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3086, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_v_real->data)); if (unlikely(__pyx_t_2 == ((npy_int)-1))) __PYX_ERR(2, 3414, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3088, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_2;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_MA_Lookback(__pyx_v_timeperiod, __pyx_v_matype));
+  __pyx_v_lookback = (__pyx_v_begidx + TA_HT_DCPERIOD_Lookback());
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3417, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3091, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_MA(0, __pyx_v_endidx, (((double *)__pyx_v_real->data) + __pyx_v_begidx), __pyx_v_timeperiod, __pyx_v_matype, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_v_outreal->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_HT_DCPERIOD(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_MA, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3419, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_HT_DCPERIOD, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3093, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outreal));
+  __Pyx_INCREF((PyObject *)__pyx_v_outreal);
   __pyx_r = ((PyObject *)__pyx_v_outreal);
   goto __pyx_L0;
 
@@ -22649,7 +27328,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_222MA(CYTHON_UNUSED PyObject *__pyx_se
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.MA", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.HT_DCPERIOD", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
@@ -22661,113 +27340,102 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_222MA(CYTHON_UNUSED PyObject *__pyx_se
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_225MACD(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_224MACD[] = " MACD(real[, fastperiod=?, slowperiod=?, signalperiod=?])\n\n    Moving Average Convergence/Divergence (Momentum Indicators)\n\n    Inputs:\n        real: (any ndarray)\n    Parameters:\n        fastperiod: 12\n        slowperiod: 26\n        signalperiod: 9\n    Outputs:\n        macd\n        macdsignal\n        macdhist\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_225MACD = {"MACD", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_225MACD, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_224MACD};
-static PyObject *__pyx_pw_5talib_7_ta_lib_225MACD(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_203HT_DCPHASE(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_202HT_DCPHASE, "HT_DCPHASE(ndarray real)\n\nHT_DCPHASE(real)\n\nHilbert Transform - Dominant Cycle Phase (Cycle Indicators)\n\nInputs:\n    real: (any ndarray)\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_203HT_DCPHASE = {"HT_DCPHASE", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_203HT_DCPHASE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_202HT_DCPHASE};
+static PyObject *__pyx_pw_5talib_7_ta_lib_203HT_DCPHASE(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_real = 0;
-  int __pyx_v_fastperiod;
-  int __pyx_v_slowperiod;
-  int __pyx_v_signalperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("MACD (wrapper)", 0);
+  __Pyx_RefNannySetupContext("HT_DCPHASE (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_fastperiod,&__pyx_n_s_slowperiod,&__pyx_n_s_signalperiod,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 3096, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3096, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_fastperiod);
-          if (value) { values[1] = value; kw_args--; }
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_slowperiod);
-          if (value) { values[2] = value; kw_args--; }
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_signalperiod);
-          if (value) { values[3] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "MACD") < 0)) __PYX_ERR(2, 3424, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "HT_DCPHASE", 0) < (0)) __PYX_ERR(4, 3096, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("HT_DCPHASE", 1, 1, 1, i); __PYX_ERR(4, 3096, __pyx_L3_error) }
       }
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-        break;
-        default: goto __pyx_L5_argtuple_error;
-      }
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3096, __pyx_L3_error)
     }
     __pyx_v_real = ((PyArrayObject *)values[0]);
-    if (values[1]) {
-      __pyx_v_fastperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_fastperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 3424, __pyx_L3_error)
-    } else {
-      __pyx_v_fastperiod = ((int)-2147483648);
-    }
-    if (values[2]) {
-      __pyx_v_slowperiod = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_slowperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 3424, __pyx_L3_error)
-    } else {
-      __pyx_v_slowperiod = ((int)-2147483648);
-    }
-    if (values[3]) {
-      __pyx_v_signalperiod = __Pyx_PyInt_As_int(values[3]); if (unlikely((__pyx_v_signalperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 3424, __pyx_L3_error)
-    } else {
-      __pyx_v_signalperiod = ((int)-2147483648);
-    }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("MACD", 0, 1, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 3424, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("HT_DCPHASE", 1, 1, 1, __pyx_nargs); __PYX_ERR(4, 3096, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.MACD", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.HT_DCPHASE", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(2, 3424, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_224MACD(__pyx_self, __pyx_v_real, __pyx_v_fastperiod, __pyx_v_slowperiod, __pyx_v_signalperiod);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 3098, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_202HT_DCPHASE(__pyx_self, __pyx_v_real);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_224MACD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_fastperiod, int __pyx_v_slowperiod, int __pyx_v_signalperiod) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_202HT_DCPHASE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -22775,77 +27443,55 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_224MACD(CYTHON_UNUSED PyObject *__pyx_
   TA_RetCode __pyx_v_retCode;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  PyArrayObject *__pyx_v_outmacd = 0;
-  PyArrayObject *__pyx_v_outmacdsignal = 0;
-  PyArrayObject *__pyx_v_outmacdhist = 0;
+  PyArrayObject *__pyx_v_outreal = 0;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_int __pyx_t_2;
-  __Pyx_RefNannySetupContext("MACD", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("HT_DCPHASE", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3449, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3115, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_v_real->data)); if (unlikely(__pyx_t_2 == ((npy_int)-1))) __PYX_ERR(2, 3451, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3117, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_2;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_MACD_Lookback(__pyx_v_fastperiod, __pyx_v_slowperiod, __pyx_v_signalperiod));
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3454, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_v_outmacd = ((PyArrayObject *)__pyx_t_1);
-  __pyx_t_1 = 0;
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3455, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_v_outmacdsignal = ((PyArrayObject *)__pyx_t_1);
-  __pyx_t_1 = 0;
+  __pyx_v_lookback = (__pyx_v_begidx + TA_HT_DCPHASE_Lookback());
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3456, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3120, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_v_outmacdhist = ((PyArrayObject *)__pyx_t_1);
+  __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_MACD(0, __pyx_v_endidx, (((double *)__pyx_v_real->data) + __pyx_v_begidx), __pyx_v_fastperiod, __pyx_v_slowperiod, __pyx_v_signalperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_v_outmacd->data) + __pyx_v_lookback), (((double *)__pyx_v_outmacdsignal->data) + __pyx_v_lookback), (((double *)__pyx_v_outmacdhist->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_HT_DCPHASE(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_MACD, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3458, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_HT_DCPHASE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3122, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3459, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outmacd));
-  __Pyx_GIVEREF(((PyObject *)__pyx_v_outmacd));
-  PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_outmacd));
-  __Pyx_INCREF(((PyObject *)__pyx_v_outmacdsignal));
-  __Pyx_GIVEREF(((PyObject *)__pyx_v_outmacdsignal));
-  PyTuple_SET_ITEM(__pyx_t_1, 1, ((PyObject *)__pyx_v_outmacdsignal));
-  __Pyx_INCREF(((PyObject *)__pyx_v_outmacdhist));
-  __Pyx_GIVEREF(((PyObject *)__pyx_v_outmacdhist));
-  PyTuple_SET_ITEM(__pyx_t_1, 2, ((PyObject *)__pyx_v_outmacdhist));
-  __pyx_r = __pyx_t_1;
-  __pyx_t_1 = 0;
+  __Pyx_INCREF((PyObject *)__pyx_v_outreal);
+  __pyx_r = ((PyObject *)__pyx_v_outreal);
   goto __pyx_L0;
 
 
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.MACD", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.HT_DCPHASE", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_outmacd);
-  __Pyx_XDECREF((PyObject *)__pyx_v_outmacdsignal);
-  __Pyx_XDECREF((PyObject *)__pyx_v_outmacdhist);
+  __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
   __Pyx_XDECREF((PyObject *)__pyx_v_real);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
@@ -22854,161 +27500,102 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_224MACD(CYTHON_UNUSED PyObject *__pyx_
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_227MACDEXT(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_226MACDEXT[] = " MACDEXT(real[, fastperiod=?, fastmatype=?, slowperiod=?, slowmatype=?, signalperiod=?, signalmatype=?])\n\n    MACD with controllable MA type (Momentum Indicators)\n\n    Inputs:\n        real: (any ndarray)\n    Parameters:\n        fastperiod: 12\n        fastmatype: 0\n        slowperiod: 26\n        slowmatype: 0\n        signalperiod: 9\n        signalmatype: 0\n    Outputs:\n        macd\n        macdsignal\n        macdhist\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_227MACDEXT = {"MACDEXT", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_227MACDEXT, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_226MACDEXT};
-static PyObject *__pyx_pw_5talib_7_ta_lib_227MACDEXT(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_205HT_PHASOR(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_204HT_PHASOR, "HT_PHASOR(ndarray real)\n\nHT_PHASOR(real)\n\nHilbert Transform - Phasor Components (Cycle Indicators)\n\nInputs:\n    real: (any ndarray)\nOutputs:\n    inphase\n    quadrature");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_205HT_PHASOR = {"HT_PHASOR", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_205HT_PHASOR, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_204HT_PHASOR};
+static PyObject *__pyx_pw_5talib_7_ta_lib_205HT_PHASOR(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_real = 0;
-  int __pyx_v_fastperiod;
-  int __pyx_v_fastmatype;
-  int __pyx_v_slowperiod;
-  int __pyx_v_slowmatype;
-  int __pyx_v_signalperiod;
-  int __pyx_v_signalmatype;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("MACDEXT (wrapper)", 0);
+  __Pyx_RefNannySetupContext("HT_PHASOR (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_fastperiod,&__pyx_n_s_fastmatype,&__pyx_n_s_slowperiod,&__pyx_n_s_slowmatype,&__pyx_n_s_signalperiod,&__pyx_n_s_signalmatype,0};
-    PyObject* values[7] = {0,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  7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6);
-        CYTHON_FALLTHROUGH;
-        case  6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
-        CYTHON_FALLTHROUGH;
-        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
-        CYTHON_FALLTHROUGH;
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 3125, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3125, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_fastperiod);
-          if (value) { values[1] = value; kw_args--; }
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_fastmatype);
-          if (value) { values[2] = value; kw_args--; }
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_slowperiod);
-          if (value) { values[3] = value; kw_args--; }
-        }
-        CYTHON_FALLTHROUGH;
-        case  4:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_slowmatype);
-          if (value) { values[4] = value; kw_args--; }
-        }
-        CYTHON_FALLTHROUGH;
-        case  5:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_signalperiod);
-          if (value) { values[5] = value; kw_args--; }
-        }
-        CYTHON_FALLTHROUGH;
-        case  6:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_signalmatype);
-          if (value) { values[6] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "MACDEXT") < 0)) __PYX_ERR(2, 3463, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "HT_PHASOR", 0) < (0)) __PYX_ERR(4, 3125, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("HT_PHASOR", 1, 1, 1, i); __PYX_ERR(4, 3125, __pyx_L3_error) }
       }
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6);
-        CYTHON_FALLTHROUGH;
-        case  6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
-        CYTHON_FALLTHROUGH;
-        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
-        CYTHON_FALLTHROUGH;
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-        break;
-        default: goto __pyx_L5_argtuple_error;
-      }
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3125, __pyx_L3_error)
     }
     __pyx_v_real = ((PyArrayObject *)values[0]);
-    if (values[1]) {
-      __pyx_v_fastperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_fastperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 3463, __pyx_L3_error)
-    } else {
-      __pyx_v_fastperiod = ((int)-2147483648);
-    }
-    if (values[2]) {
-      __pyx_v_fastmatype = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_fastmatype == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 3463, __pyx_L3_error)
-    } else {
-      __pyx_v_fastmatype = ((int)0);
-    }
-    if (values[3]) {
-      __pyx_v_slowperiod = __Pyx_PyInt_As_int(values[3]); if (unlikely((__pyx_v_slowperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 3463, __pyx_L3_error)
-    } else {
-      __pyx_v_slowperiod = ((int)-2147483648);
-    }
-    if (values[4]) {
-      __pyx_v_slowmatype = __Pyx_PyInt_As_int(values[4]); if (unlikely((__pyx_v_slowmatype == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 3463, __pyx_L3_error)
-    } else {
-      __pyx_v_slowmatype = ((int)0);
-    }
-    if (values[5]) {
-      __pyx_v_signalperiod = __Pyx_PyInt_As_int(values[5]); if (unlikely((__pyx_v_signalperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 3463, __pyx_L3_error)
-    } else {
-      __pyx_v_signalperiod = ((int)-2147483648);
-    }
-    if (values[6]) {
-      __pyx_v_signalmatype = __Pyx_PyInt_As_int(values[6]); if (unlikely((__pyx_v_signalmatype == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 3463, __pyx_L3_error)
-    } else {
-      __pyx_v_signalmatype = ((int)0);
-    }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("MACDEXT", 0, 1, 7, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 3463, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("HT_PHASOR", 1, 1, 1, __pyx_nargs); __PYX_ERR(4, 3125, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.MACDEXT", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.HT_PHASOR", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(2, 3463, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_226MACDEXT(__pyx_self, __pyx_v_real, __pyx_v_fastperiod, __pyx_v_fastmatype, __pyx_v_slowperiod, __pyx_v_slowmatype, __pyx_v_signalperiod, __pyx_v_signalmatype);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 3127, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_204HT_PHASOR(__pyx_self, __pyx_v_real);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_226MACDEXT(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_fastperiod, int __pyx_v_fastmatype, int __pyx_v_slowperiod, int __pyx_v_slowmatype, int __pyx_v_signalperiod, int __pyx_v_signalmatype) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_204HT_PHASOR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -23016,63 +27603,57 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_226MACDEXT(CYTHON_UNUSED PyObject *__p
   TA_RetCode __pyx_v_retCode;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  PyArrayObject *__pyx_v_outmacd = 0;
-  PyArrayObject *__pyx_v_outmacdsignal = 0;
-  PyArrayObject *__pyx_v_outmacdhist = 0;
+  PyArrayObject *__pyx_v_outinphase = 0;
+  PyArrayObject *__pyx_v_outquadrature = 0;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_int __pyx_t_2;
-  __Pyx_RefNannySetupContext("MACDEXT", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("HT_PHASOR", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3491, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3146, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_v_real->data)); if (unlikely(__pyx_t_2 == ((npy_int)-1))) __PYX_ERR(2, 3493, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3148, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_2;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_MACDEXT_Lookback(__pyx_v_fastperiod, __pyx_v_fastmatype, __pyx_v_slowperiod, __pyx_v_slowmatype, __pyx_v_signalperiod, __pyx_v_signalmatype));
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3496, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_v_outmacd = ((PyArrayObject *)__pyx_t_1);
-  __pyx_t_1 = 0;
+  __pyx_v_lookback = (__pyx_v_begidx + TA_HT_PHASOR_Lookback());
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3497, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3151, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_v_outmacdsignal = ((PyArrayObject *)__pyx_t_1);
+  __pyx_v_outinphase = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3498, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3152, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_v_outmacdhist = ((PyArrayObject *)__pyx_t_1);
+  __pyx_v_outquadrature = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_MACDEXT(0, __pyx_v_endidx, (((double *)__pyx_v_real->data) + __pyx_v_begidx), __pyx_v_fastperiod, __pyx_v_fastmatype, __pyx_v_slowperiod, __pyx_v_slowmatype, __pyx_v_signalperiod, __pyx_v_signalmatype, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_v_outmacd->data) + __pyx_v_lookback), (((double *)__pyx_v_outmacdsignal->data) + __pyx_v_lookback), (((double *)__pyx_v_outmacdhist->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_HT_PHASOR(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinphase)) + __pyx_v_lookback), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outquadrature)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_MACDEXT, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3500, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_HT_PHASOR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3154, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3501, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outmacd));
-  __Pyx_GIVEREF(((PyObject *)__pyx_v_outmacd));
-  PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_outmacd));
-  __Pyx_INCREF(((PyObject *)__pyx_v_outmacdsignal));
-  __Pyx_GIVEREF(((PyObject *)__pyx_v_outmacdsignal));
-  PyTuple_SET_ITEM(__pyx_t_1, 1, ((PyObject *)__pyx_v_outmacdsignal));
-  __Pyx_INCREF(((PyObject *)__pyx_v_outmacdhist));
-  __Pyx_GIVEREF(((PyObject *)__pyx_v_outmacdhist));
-  PyTuple_SET_ITEM(__pyx_t_1, 2, ((PyObject *)__pyx_v_outmacdhist));
+  __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3155, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_INCREF((PyObject *)__pyx_v_outinphase);
+  __Pyx_GIVEREF((PyObject *)__pyx_v_outinphase);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_outinphase)) != (0)) __PYX_ERR(4, 3155, __pyx_L1_error);
+  __Pyx_INCREF((PyObject *)__pyx_v_outquadrature);
+  __Pyx_GIVEREF((PyObject *)__pyx_v_outquadrature);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, ((PyObject *)__pyx_v_outquadrature)) != (0)) __PYX_ERR(4, 3155, __pyx_L1_error);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
   goto __pyx_L0;
@@ -23081,12 +27662,11 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_226MACDEXT(CYTHON_UNUSED PyObject *__p
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.MACDEXT", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.HT_PHASOR", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_outmacd);
-  __Pyx_XDECREF((PyObject *)__pyx_v_outmacdsignal);
-  __Pyx_XDECREF((PyObject *)__pyx_v_outmacdhist);
+  __Pyx_XDECREF((PyObject *)__pyx_v_outinphase);
+  __Pyx_XDECREF((PyObject *)__pyx_v_outquadrature);
   __Pyx_XDECREF((PyObject *)__pyx_v_real);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
@@ -23095,81 +27675,102 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_226MACDEXT(CYTHON_UNUSED PyObject *__p
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_229MACDFIX(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_228MACDFIX[] = " MACDFIX(real[, signalperiod=?])\n\n    Moving Average Convergence/Divergence Fix 12/26 (Momentum Indicators)\n\n    Inputs:\n        real: (any ndarray)\n    Parameters:\n        signalperiod: 9\n    Outputs:\n        macd\n        macdsignal\n        macdhist\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_229MACDFIX = {"MACDFIX", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_229MACDFIX, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_228MACDFIX};
-static PyObject *__pyx_pw_5talib_7_ta_lib_229MACDFIX(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_207HT_SINE(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_206HT_SINE, "HT_SINE(ndarray real)\n\nHT_SINE(real)\n\nHilbert Transform - SineWave (Cycle Indicators)\n\nInputs:\n    real: (any ndarray)\nOutputs:\n    sine\n    leadsine");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_207HT_SINE = {"HT_SINE", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_207HT_SINE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_206HT_SINE};
+static PyObject *__pyx_pw_5talib_7_ta_lib_207HT_SINE(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_real = 0;
-  int __pyx_v_signalperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("MACDFIX (wrapper)", 0);
+  __Pyx_RefNannySetupContext("HT_SINE (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_signalperiod,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);
-        CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 3157, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3157, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_signalperiod);
-          if (value) { values[1] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "MACDFIX") < 0)) __PYX_ERR(2, 3505, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "HT_SINE", 0) < (0)) __PYX_ERR(4, 3157, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("HT_SINE", 1, 1, 1, i); __PYX_ERR(4, 3157, __pyx_L3_error) }
       }
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-        break;
-        default: goto __pyx_L5_argtuple_error;
-      }
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3157, __pyx_L3_error)
     }
     __pyx_v_real = ((PyArrayObject *)values[0]);
-    if (values[1]) {
-      __pyx_v_signalperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_signalperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 3505, __pyx_L3_error)
-    } else {
-      __pyx_v_signalperiod = ((int)-2147483648);
-    }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("MACDFIX", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 3505, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("HT_SINE", 1, 1, 1, __pyx_nargs); __PYX_ERR(4, 3157, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.MACDFIX", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.HT_SINE", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(2, 3505, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_228MACDFIX(__pyx_self, __pyx_v_real, __pyx_v_signalperiod);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 3159, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_206HT_SINE(__pyx_self, __pyx_v_real);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_228MACDFIX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_signalperiod) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_206HT_SINE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -23177,63 +27778,57 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_228MACDFIX(CYTHON_UNUSED PyObject *__p
   TA_RetCode __pyx_v_retCode;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  PyArrayObject *__pyx_v_outmacd = 0;
-  PyArrayObject *__pyx_v_outmacdsignal = 0;
-  PyArrayObject *__pyx_v_outmacdhist = 0;
+  PyArrayObject *__pyx_v_outsine = 0;
+  PyArrayObject *__pyx_v_outleadsine = 0;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_int __pyx_t_2;
-  __Pyx_RefNannySetupContext("MACDFIX", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("HT_SINE", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3528, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3178, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_v_real->data)); if (unlikely(__pyx_t_2 == ((npy_int)-1))) __PYX_ERR(2, 3530, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3180, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_2;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_MACDFIX_Lookback(__pyx_v_signalperiod));
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3533, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_v_outmacd = ((PyArrayObject *)__pyx_t_1);
-  __pyx_t_1 = 0;
+  __pyx_v_lookback = (__pyx_v_begidx + TA_HT_SINE_Lookback());
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3534, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3183, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_v_outmacdsignal = ((PyArrayObject *)__pyx_t_1);
+  __pyx_v_outsine = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3535, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3184, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_v_outmacdhist = ((PyArrayObject *)__pyx_t_1);
+  __pyx_v_outleadsine = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_MACDFIX(0, __pyx_v_endidx, (((double *)__pyx_v_real->data) + __pyx_v_begidx), __pyx_v_signalperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_v_outmacd->data) + __pyx_v_lookback), (((double *)__pyx_v_outmacdsignal->data) + __pyx_v_lookback), (((double *)__pyx_v_outmacdhist->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_HT_SINE(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outsine)) + __pyx_v_lookback), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outleadsine)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_MACDFIX, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3537, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_HT_SINE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3186, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3538, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outmacd));
-  __Pyx_GIVEREF(((PyObject *)__pyx_v_outmacd));
-  PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_outmacd));
-  __Pyx_INCREF(((PyObject *)__pyx_v_outmacdsignal));
-  __Pyx_GIVEREF(((PyObject *)__pyx_v_outmacdsignal));
-  PyTuple_SET_ITEM(__pyx_t_1, 1, ((PyObject *)__pyx_v_outmacdsignal));
-  __Pyx_INCREF(((PyObject *)__pyx_v_outmacdhist));
-  __Pyx_GIVEREF(((PyObject *)__pyx_v_outmacdhist));
-  PyTuple_SET_ITEM(__pyx_t_1, 2, ((PyObject *)__pyx_v_outmacdhist));
+  __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3187, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_INCREF((PyObject *)__pyx_v_outsine);
+  __Pyx_GIVEREF((PyObject *)__pyx_v_outsine);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_outsine)) != (0)) __PYX_ERR(4, 3187, __pyx_L1_error);
+  __Pyx_INCREF((PyObject *)__pyx_v_outleadsine);
+  __Pyx_GIVEREF((PyObject *)__pyx_v_outleadsine);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, ((PyObject *)__pyx_v_outleadsine)) != (0)) __PYX_ERR(4, 3187, __pyx_L1_error);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
   goto __pyx_L0;
@@ -23242,12 +27837,11 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_228MACDFIX(CYTHON_UNUSED PyObject *__p
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.MACDFIX", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.HT_SINE", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_outmacd);
-  __Pyx_XDECREF((PyObject *)__pyx_v_outmacdsignal);
-  __Pyx_XDECREF((PyObject *)__pyx_v_outmacdhist);
+  __Pyx_XDECREF((PyObject *)__pyx_v_outsine);
+  __Pyx_XDECREF((PyObject *)__pyx_v_outleadsine);
   __Pyx_XDECREF((PyObject *)__pyx_v_real);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
@@ -23256,97 +27850,102 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_228MACDFIX(CYTHON_UNUSED PyObject *__p
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_231MAMA(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_230MAMA[] = " MAMA(real[, fastlimit=?, slowlimit=?])\n\n    MESA Adaptive Moving Average (Overlap Studies)\n\n    Inputs:\n        real: (any ndarray)\n    Parameters:\n        fastlimit: 0.5\n        slowlimit: 0.05\n    Outputs:\n        mama\n        fama\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_231MAMA = {"MAMA", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_231MAMA, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_230MAMA};
-static PyObject *__pyx_pw_5talib_7_ta_lib_231MAMA(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_209HT_TRENDLINE(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_208HT_TRENDLINE, "HT_TRENDLINE(ndarray real)\n\nHT_TRENDLINE(real)\n\nHilbert Transform - Instantaneous Trendline (Overlap Studies)\n\nInputs:\n    real: (any ndarray)\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_209HT_TRENDLINE = {"HT_TRENDLINE", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_209HT_TRENDLINE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_208HT_TRENDLINE};
+static PyObject *__pyx_pw_5talib_7_ta_lib_209HT_TRENDLINE(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_real = 0;
-  double __pyx_v_fastlimit;
-  double __pyx_v_slowlimit;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("MAMA (wrapper)", 0);
+  __Pyx_RefNannySetupContext("HT_TRENDLINE (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_fastlimit,&__pyx_n_s_slowlimit,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);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 3189, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3189, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_fastlimit);
-          if (value) { values[1] = value; kw_args--; }
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_slowlimit);
-          if (value) { values[2] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "MAMA") < 0)) __PYX_ERR(2, 3542, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "HT_TRENDLINE", 0) < (0)) __PYX_ERR(4, 3189, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("HT_TRENDLINE", 1, 1, 1, i); __PYX_ERR(4, 3189, __pyx_L3_error) }
       }
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-        break;
-        default: goto __pyx_L5_argtuple_error;
-      }
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3189, __pyx_L3_error)
     }
     __pyx_v_real = ((PyArrayObject *)values[0]);
-    if (values[1]) {
-      __pyx_v_fastlimit = __pyx_PyFloat_AsDouble(values[1]); if (unlikely((__pyx_v_fastlimit == (double)-1) && PyErr_Occurred())) __PYX_ERR(2, 3542, __pyx_L3_error)
-    } else {
-      __pyx_v_fastlimit = ((double)-4e37);
-    }
-    if (values[2]) {
-      __pyx_v_slowlimit = __pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_slowlimit == (double)-1) && PyErr_Occurred())) __PYX_ERR(2, 3542, __pyx_L3_error)
-    } else {
-      __pyx_v_slowlimit = ((double)-4e37);
-    }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("MAMA", 0, 1, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 3542, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("HT_TRENDLINE", 1, 1, 1, __pyx_nargs); __PYX_ERR(4, 3189, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.MAMA", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.HT_TRENDLINE", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(2, 3542, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_230MAMA(__pyx_self, __pyx_v_real, __pyx_v_fastlimit, __pyx_v_slowlimit);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 3191, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_208HT_TRENDLINE(__pyx_self, __pyx_v_real);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_230MAMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, double __pyx_v_fastlimit, double __pyx_v_slowlimit) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_208HT_TRENDLINE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -23354,67 +27953,55 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_230MAMA(CYTHON_UNUSED PyObject *__pyx_
   TA_RetCode __pyx_v_retCode;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  PyArrayObject *__pyx_v_outmama = 0;
-  PyArrayObject *__pyx_v_outfama = 0;
+  PyArrayObject *__pyx_v_outreal = 0;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_int __pyx_t_2;
-  __Pyx_RefNannySetupContext("MAMA", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("HT_TRENDLINE", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3564, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3208, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_v_real->data)); if (unlikely(__pyx_t_2 == ((npy_int)-1))) __PYX_ERR(2, 3566, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3210, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_2;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_MAMA_Lookback(__pyx_v_fastlimit, __pyx_v_slowlimit));
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3569, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_v_outmama = ((PyArrayObject *)__pyx_t_1);
-  __pyx_t_1 = 0;
+  __pyx_v_lookback = (__pyx_v_begidx + TA_HT_TRENDLINE_Lookback());
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3570, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3213, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_v_outfama = ((PyArrayObject *)__pyx_t_1);
+  __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_MAMA(0, __pyx_v_endidx, (((double *)__pyx_v_real->data) + __pyx_v_begidx), __pyx_v_fastlimit, __pyx_v_slowlimit, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_v_outmama->data) + __pyx_v_lookback), (((double *)__pyx_v_outfama->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_HT_TRENDLINE(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_MAMA, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3572, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_HT_TRENDLINE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3215, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3573, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outmama));
-  __Pyx_GIVEREF(((PyObject *)__pyx_v_outmama));
-  PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_outmama));
-  __Pyx_INCREF(((PyObject *)__pyx_v_outfama));
-  __Pyx_GIVEREF(((PyObject *)__pyx_v_outfama));
-  PyTuple_SET_ITEM(__pyx_t_1, 1, ((PyObject *)__pyx_v_outfama));
-  __pyx_r = __pyx_t_1;
-  __pyx_t_1 = 0;
+  __Pyx_INCREF((PyObject *)__pyx_v_outreal);
+  __pyx_r = ((PyObject *)__pyx_v_outreal);
   goto __pyx_L0;
 
 
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.MAMA", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.HT_TRENDLINE", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_outmama);
-  __Pyx_XDECREF((PyObject *)__pyx_v_outfama);
+  __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
   __Pyx_XDECREF((PyObject *)__pyx_v_real);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
@@ -23423,125 +28010,102 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_230MAMA(CYTHON_UNUSED PyObject *__pyx_
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_233MAVP(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_232MAVP[] = " MAVP(real, periods[, minperiod=?, maxperiod=?, matype=?])\n\n    Moving average with variable period (Overlap Studies)\n\n    Inputs:\n        real: (any ndarray)\n        periods: (any ndarray)\n    Parameters:\n        minperiod: 2\n        maxperiod: 30\n        matype: 0 (Simple Moving Average)\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_233MAVP = {"MAVP", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_233MAVP, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_232MAVP};
-static PyObject *__pyx_pw_5talib_7_ta_lib_233MAVP(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_211HT_TRENDMODE(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_210HT_TRENDMODE, "HT_TRENDMODE(ndarray real)\n\nHT_TRENDMODE(real)\n\nHilbert Transform - Trend vs Cycle Mode (Cycle Indicators)\n\nInputs:\n    real: (any ndarray)\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_211HT_TRENDMODE = {"HT_TRENDMODE", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_211HT_TRENDMODE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_210HT_TRENDMODE};
+static PyObject *__pyx_pw_5talib_7_ta_lib_211HT_TRENDMODE(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_real = 0;
-  PyArrayObject *__pyx_v_periods = 0;
-  int __pyx_v_minperiod;
-  int __pyx_v_maxperiod;
-  int __pyx_v_matype;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("MAVP (wrapper)", 0);
+  __Pyx_RefNannySetupContext("HT_TRENDMODE (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_periods,&__pyx_n_s_minperiod,&__pyx_n_s_maxperiod,&__pyx_n_s_matype,0};
-    PyObject* values[5] = {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  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
-        CYTHON_FALLTHROUGH;
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 3218, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3218, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_periods)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("MAVP", 0, 2, 5, 1); __PYX_ERR(2, 3577, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_minperiod);
-          if (value) { values[2] = value; kw_args--; }
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_maxperiod);
-          if (value) { values[3] = value; kw_args--; }
-        }
-        CYTHON_FALLTHROUGH;
-        case  4:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_matype);
-          if (value) { values[4] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "MAVP") < 0)) __PYX_ERR(2, 3577, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "HT_TRENDMODE", 0) < (0)) __PYX_ERR(4, 3218, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("HT_TRENDMODE", 1, 1, 1, i); __PYX_ERR(4, 3218, __pyx_L3_error) }
       }
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
-        CYTHON_FALLTHROUGH;
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-        break;
-        default: goto __pyx_L5_argtuple_error;
-      }
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3218, __pyx_L3_error)
     }
     __pyx_v_real = ((PyArrayObject *)values[0]);
-    __pyx_v_periods = ((PyArrayObject *)values[1]);
-    if (values[2]) {
-      __pyx_v_minperiod = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_minperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 3577, __pyx_L3_error)
-    } else {
-      __pyx_v_minperiod = ((int)-2147483648);
-    }
-    if (values[3]) {
-      __pyx_v_maxperiod = __Pyx_PyInt_As_int(values[3]); if (unlikely((__pyx_v_maxperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 3577, __pyx_L3_error)
-    } else {
-      __pyx_v_maxperiod = ((int)-2147483648);
-    }
-    if (values[4]) {
-      __pyx_v_matype = __Pyx_PyInt_As_int(values[4]); if (unlikely((__pyx_v_matype == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 3577, __pyx_L3_error)
-    } else {
-      __pyx_v_matype = ((int)0);
-    }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("MAVP", 0, 2, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 3577, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("HT_TRENDMODE", 1, 1, 1, __pyx_nargs); __PYX_ERR(4, 3218, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.MAVP", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.HT_TRENDMODE", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(2, 3577, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_periods), __pyx_ptype_5numpy_ndarray, 0, "periods", 0))) __PYX_ERR(2, 3577, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_232MAVP(__pyx_self, __pyx_v_real, __pyx_v_periods, __pyx_v_minperiod, __pyx_v_maxperiod, __pyx_v_matype);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 3220, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_210HT_TRENDMODE(__pyx_self, __pyx_v_real);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_232MAVP(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, PyArrayObject *__pyx_v_periods, int __pyx_v_minperiod, int __pyx_v_maxperiod, int __pyx_v_matype) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_210HT_TRENDMODE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -23549,62 +28113,56 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_232MAVP(CYTHON_UNUSED PyObject *__pyx_
   TA_RetCode __pyx_v_retCode;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  PyArrayObject *__pyx_v_outreal = 0;
+  PyArrayObject *__pyx_v_outinteger = 0;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  npy_intp __pyx_t_2;
-  npy_int __pyx_t_3;
-  __Pyx_RefNannySetupContext("MAVP", 0);
+  npy_int __pyx_t_2;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("HT_TRENDMODE", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_real);
-  __Pyx_INCREF((PyObject *)__pyx_v_periods);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3599, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3237, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_periods)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3600, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_periods, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_real, __pyx_v_periods); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(2, 3601, __pyx_L1_error)
-  __pyx_v_length = __pyx_t_2;
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
-  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx2(__pyx_v_length, ((double *)__pyx_v_real->data), ((double *)__pyx_v_periods->data)); if (unlikely(__pyx_t_3 == ((npy_int)-1))) __PYX_ERR(2, 3602, __pyx_L1_error)
-  __pyx_v_begidx = __pyx_t_3;
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3239, __pyx_L1_error)
+  __pyx_v_begidx = __pyx_t_2;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_MAVP_Lookback(__pyx_v_minperiod, __pyx_v_maxperiod, __pyx_v_matype));
+  __pyx_v_lookback = (__pyx_v_begidx + TA_HT_TRENDMODE_Lookback());
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3605, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3242, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
+  __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_MAVP(0, __pyx_v_endidx, (((double *)__pyx_v_real->data) + __pyx_v_begidx), (((double *)__pyx_v_periods->data) + __pyx_v_begidx), __pyx_v_minperiod, __pyx_v_maxperiod, __pyx_v_matype, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_v_outreal->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_HT_TRENDMODE(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_MAVP, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3607, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_HT_TRENDMODE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3244, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outreal));
-  __pyx_r = ((PyObject *)__pyx_v_outreal);
+  __Pyx_INCREF((PyObject *)__pyx_v_outinteger);
+  __pyx_r = ((PyObject *)__pyx_v_outinteger);
   goto __pyx_L0;
 
 
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.MAVP", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.HT_TRENDMODE", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
+  __Pyx_XDECREF((PyObject *)__pyx_v_outinteger);
   __Pyx_XDECREF((PyObject *)__pyx_v_real);
-  __Pyx_XDECREF((PyObject *)__pyx_v_periods);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -23612,81 +28170,128 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_232MAVP(CYTHON_UNUSED PyObject *__pyx_
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_235MAX(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_234MAX[] = " MAX(real[, timeperiod=?])\n\n    Highest value over a specified period (Math Operators)\n\n    Inputs:\n        real: (any ndarray)\n    Parameters:\n        timeperiod: 30\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_235MAX = {"MAX", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_235MAX, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_234MAX};
-static PyObject *__pyx_pw_5talib_7_ta_lib_235MAX(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_real = 0;
+static PyObject *__pyx_pw_5talib_7_ta_lib_213IMI(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_212IMI, "IMI(ndarray open, ndarray close, int timeperiod=-0x80000000)\n\nIMI(open, close[, timeperiod=?])\n\nIntraday Momentum Index (Momentum Indicators)\n\nInputs:\n    prices: ['open', 'close']\nParameters:\n    timeperiod: 14\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_213IMI = {"IMI", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_213IMI, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_212IMI};
+static PyObject *__pyx_pw_5talib_7_ta_lib_213IMI(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_open = 0;
+  PyArrayObject *__pyx_v_close = 0;
   int __pyx_v_timeperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[3] = {0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("MAX (wrapper)", 0);
+  __Pyx_RefNannySetupContext("IMI (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,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);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_close,&__pyx_mstate_global->__pyx_n_u_timeperiod,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 3247, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 3247, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 3247, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3247, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod);
-          if (value) { values[1] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "MAX") < 0)) __PYX_ERR(2, 3612, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "IMI", 0) < (0)) __PYX_ERR(4, 3247, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("IMI", 0, 2, 3, i); __PYX_ERR(4, 3247, __pyx_L3_error) }
       }
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      switch (__pyx_nargs) {
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 3247, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 3247, __pyx_L3_error)
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3247, __pyx_L3_error)
         break;
         default: goto __pyx_L5_argtuple_error;
       }
     }
-    __pyx_v_real = ((PyArrayObject *)values[0]);
-    if (values[1]) {
-      __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 3612, __pyx_L3_error)
+    __pyx_v_open = ((PyArrayObject *)values[0]);
+    __pyx_v_close = ((PyArrayObject *)values[1]);
+    if (values[2]) {
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[2]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3249, __pyx_L3_error)
     } else {
-      __pyx_v_timeperiod = ((int)-2147483648);
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
     }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("MAX", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 3612, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("IMI", 0, 2, 3, __pyx_nargs); __PYX_ERR(4, 3247, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.MAX", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.IMI", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(2, 3612, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_234MAX(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(4, 3249, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 3249, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_212IMI(__pyx_self, __pyx_v_open, __pyx_v_close, __pyx_v_timeperiod);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_234MAX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_212IMI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -23698,37 +28303,48 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_234MAX(CYTHON_UNUSED PyObject *__pyx_s
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  npy_int __pyx_t_2;
-  __Pyx_RefNannySetupContext("MAX", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_real);
+  npy_intp __pyx_t_2;
+  npy_int __pyx_t_3;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("IMI", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_open);
+  __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3631, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3268, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
+
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3269, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_open, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 3270, __pyx_L1_error)
+  __pyx_v_length = __pyx_t_2;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_v_real->data)); if (unlikely(__pyx_t_2 == ((npy_int)-1))) __PYX_ERR(2, 3633, __pyx_L1_error)
-  __pyx_v_begidx = __pyx_t_2;
+  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx2(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3271, __pyx_L1_error)
+  __pyx_v_begidx = __pyx_t_3;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_MAX_Lookback(__pyx_v_timeperiod));
+  __pyx_v_lookback = (__pyx_v_begidx + TA_IMI_Lookback(__pyx_v_timeperiod));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3636, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3274, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_MAX(0, __pyx_v_endidx, (((double *)__pyx_v_real->data) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_v_outreal->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_IMI(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_MAX, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3638, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_IMI, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3276, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outreal));
+  __Pyx_INCREF((PyObject *)__pyx_v_outreal);
   __pyx_r = ((PyObject *)__pyx_v_outreal);
   goto __pyx_L0;
 
@@ -23736,11 +28352,12 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_234MAX(CYTHON_UNUSED PyObject *__pyx_s
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.MAX", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.IMI", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
-  __Pyx_XDECREF((PyObject *)__pyx_v_real);
+  __Pyx_XDECREF((PyObject *)__pyx_v_open);
+  __Pyx_XDECREF((PyObject *)__pyx_v_close);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -23748,81 +28365,119 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_234MAX(CYTHON_UNUSED PyObject *__pyx_s
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_237MAXINDEX(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_236MAXINDEX[] = " MAXINDEX(real[, timeperiod=?])\n\n    Index of highest value over a specified period (Math Operators)\n\n    Inputs:\n        real: (any ndarray)\n    Parameters:\n        timeperiod: 30\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_237MAXINDEX = {"MAXINDEX", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_237MAXINDEX, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_236MAXINDEX};
-static PyObject *__pyx_pw_5talib_7_ta_lib_237MAXINDEX(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_215KAMA(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_214KAMA, "KAMA(ndarray real, int timeperiod=-0x80000000)\n\nKAMA(real[, timeperiod=?])\n\nKaufman Adaptive Moving Average (Overlap Studies)\n\nInputs:\n    real: (any ndarray)\nParameters:\n    timeperiod: 30\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_215KAMA = {"KAMA", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_215KAMA, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_214KAMA};
+static PyObject *__pyx_pw_5talib_7_ta_lib_215KAMA(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_real = 0;
   int __pyx_v_timeperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("MAXINDEX (wrapper)", 0);
+  __Pyx_RefNannySetupContext("KAMA (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,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);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 3279, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 3279, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3279, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod);
-          if (value) { values[1] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "MAXINDEX") < 0)) __PYX_ERR(2, 3643, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "KAMA", 0) < (0)) __PYX_ERR(4, 3279, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("KAMA", 0, 1, 2, i); __PYX_ERR(4, 3279, __pyx_L3_error) }
       }
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 3279, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3279, __pyx_L3_error)
         break;
         default: goto __pyx_L5_argtuple_error;
       }
     }
     __pyx_v_real = ((PyArrayObject *)values[0]);
     if (values[1]) {
-      __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 3643, __pyx_L3_error)
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3281, __pyx_L3_error)
     } else {
-      __pyx_v_timeperiod = ((int)-2147483648);
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
     }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("MAXINDEX", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 3643, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("KAMA", 0, 1, 2, __pyx_nargs); __PYX_ERR(4, 3279, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.MAXINDEX", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.KAMA", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(2, 3643, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_236MAXINDEX(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 3281, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_214KAMA(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_236MAXINDEX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_214KAMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -23830,52 +28485,55 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_236MAXINDEX(CYTHON_UNUSED PyObject *__
   TA_RetCode __pyx_v_retCode;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  PyArrayObject *__pyx_v_outinteger = 0;
+  PyArrayObject *__pyx_v_outreal = 0;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_int __pyx_t_2;
-  __Pyx_RefNannySetupContext("MAXINDEX", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("KAMA", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3662, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3300, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_v_real->data)); if (unlikely(__pyx_t_2 == ((npy_int)-1))) __PYX_ERR(2, 3664, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3302, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_2;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_MAXINDEX_Lookback(__pyx_v_timeperiod));
+  __pyx_v_lookback = (__pyx_v_begidx + TA_KAMA_Lookback(__pyx_v_timeperiod));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3667, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3305, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1);
+  __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_MAXINDEX(0, __pyx_v_endidx, (((double *)__pyx_v_real->data) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_v_outinteger->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_KAMA(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_MAXINDEX, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3669, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_KAMA, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3307, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outinteger));
-  __pyx_r = ((PyObject *)__pyx_v_outinteger);
+  __Pyx_INCREF((PyObject *)__pyx_v_outreal);
+  __pyx_r = ((PyObject *)__pyx_v_outreal);
   goto __pyx_L0;
 
 
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.MAXINDEX", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.KAMA", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_outinteger);
+  __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
   __Pyx_XDECREF((PyObject *)__pyx_v_real);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
@@ -23884,75 +28542,119 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_236MAXINDEX(CYTHON_UNUSED PyObject *__
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_239MEDPRICE(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_238MEDPRICE[] = " MEDPRICE(high, low)\n\n    Median Price (Price Transform)\n\n    Inputs:\n        prices: ['high', 'low']\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_239MEDPRICE = {"MEDPRICE", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_239MEDPRICE, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_238MEDPRICE};
-static PyObject *__pyx_pw_5talib_7_ta_lib_239MEDPRICE(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_high = 0;
-  PyArrayObject *__pyx_v_low = 0;
+static PyObject *__pyx_pw_5talib_7_ta_lib_217LINEARREG(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_216LINEARREG, "LINEARREG(ndarray real, int timeperiod=-0x80000000)\n\nLINEARREG(real[, timeperiod=?])\n\nLinear Regression (Statistic Functions)\n\nInputs:\n    real: (any ndarray)\nParameters:\n    timeperiod: 14\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_217LINEARREG = {"LINEARREG", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_217LINEARREG, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_216LINEARREG};
+static PyObject *__pyx_pw_5talib_7_ta_lib_217LINEARREG(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_real = 0;
+  int __pyx_v_timeperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("MEDPRICE (wrapper)", 0);
+  __Pyx_RefNannySetupContext("LINEARREG (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,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);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 3310, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 3310, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3310, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "LINEARREG", 0) < (0)) __PYX_ERR(4, 3310, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("LINEARREG", 0, 1, 2, i); __PYX_ERR(4, 3310, __pyx_L3_error) }
+      }
+    } else {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 3310, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("MEDPRICE", 1, 2, 2, 1); __PYX_ERR(2, 3674, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "MEDPRICE") < 0)) __PYX_ERR(2, 3674, __pyx_L3_error)
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3310, __pyx_L3_error)
+        break;
+        default: goto __pyx_L5_argtuple_error;
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
-      goto __pyx_L5_argtuple_error;
+    }
+    __pyx_v_real = ((PyArrayObject *)values[0]);
+    if (values[1]) {
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3312, __pyx_L3_error)
     } else {
-      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
     }
-    __pyx_v_high = ((PyArrayObject *)values[0]);
-    __pyx_v_low = ((PyArrayObject *)values[1]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("MEDPRICE", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 3674, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("LINEARREG", 0, 1, 2, __pyx_nargs); __PYX_ERR(4, 3310, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.MEDPRICE", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.LINEARREG", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(2, 3674, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(2, 3674, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_238MEDPRICE(__pyx_self, __pyx_v_high, __pyx_v_low);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 3312, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_216LINEARREG(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_238MEDPRICE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_216LINEARREG(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -23964,45 +28666,40 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_238MEDPRICE(CYTHON_UNUSED PyObject *__
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  npy_intp __pyx_t_2;
-  npy_int __pyx_t_3;
-  __Pyx_RefNannySetupContext("MEDPRICE", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_high);
-  __Pyx_INCREF((PyObject *)__pyx_v_low);
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3691, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
+  npy_int __pyx_t_2;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("LINEARREG", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3692, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3331, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_high, __pyx_v_low); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(2, 3693, __pyx_L1_error)
-  __pyx_v_length = __pyx_t_2;
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
-  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx2(__pyx_v_length, ((double *)__pyx_v_high->data), ((double *)__pyx_v_low->data)); if (unlikely(__pyx_t_3 == ((npy_int)-1))) __PYX_ERR(2, 3694, __pyx_L1_error)
-  __pyx_v_begidx = __pyx_t_3;
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3333, __pyx_L1_error)
+  __pyx_v_begidx = __pyx_t_2;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_MEDPRICE_Lookback());
+  __pyx_v_lookback = (__pyx_v_begidx + TA_LINEARREG_Lookback(__pyx_v_timeperiod));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3697, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3336, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_MEDPRICE(0, __pyx_v_endidx, (((double *)__pyx_v_high->data) + __pyx_v_begidx), (((double *)__pyx_v_low->data) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_v_outreal->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_LINEARREG(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_MEDPRICE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3699, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_LINEARREG, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3338, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outreal));
+  __Pyx_INCREF((PyObject *)__pyx_v_outreal);
   __pyx_r = ((PyObject *)__pyx_v_outreal);
   goto __pyx_L0;
 
@@ -24010,12 +28707,11 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_238MEDPRICE(CYTHON_UNUSED PyObject *__
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.MEDPRICE", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.LINEARREG", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
-  __Pyx_XDECREF((PyObject *)__pyx_v_high);
-  __Pyx_XDECREF((PyObject *)__pyx_v_low);
+  __Pyx_XDECREF((PyObject *)__pyx_v_real);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -24023,117 +28719,119 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_238MEDPRICE(CYTHON_UNUSED PyObject *__
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_241MFI(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_240MFI[] = " MFI(high, low, close, volume[, timeperiod=?])\n\n    Money Flow Index (Momentum Indicators)\n\n    Inputs:\n        prices: ['high', 'low', 'close', 'volume']\n    Parameters:\n        timeperiod: 14\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_241MFI = {"MFI", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_241MFI, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_240MFI};
-static PyObject *__pyx_pw_5talib_7_ta_lib_241MFI(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_high = 0;
-  PyArrayObject *__pyx_v_low = 0;
-  PyArrayObject *__pyx_v_close = 0;
-  PyArrayObject *__pyx_v_volume = 0;
+static PyObject *__pyx_pw_5talib_7_ta_lib_219LINEARREG_ANGLE(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_218LINEARREG_ANGLE, "LINEARREG_ANGLE(ndarray real, int timeperiod=-0x80000000)\n\nLINEARREG_ANGLE(real[, timeperiod=?])\n\nLinear Regression Angle (Statistic Functions)\n\nInputs:\n    real: (any ndarray)\nParameters:\n    timeperiod: 14\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_219LINEARREG_ANGLE = {"LINEARREG_ANGLE", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_219LINEARREG_ANGLE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_218LINEARREG_ANGLE};
+static PyObject *__pyx_pw_5talib_7_ta_lib_219LINEARREG_ANGLE(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_real = 0;
   int __pyx_v_timeperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("MFI (wrapper)", 0);
+  __Pyx_RefNannySetupContext("LINEARREG_ANGLE (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,&__pyx_n_s_volume,&__pyx_n_s_timeperiod,0};
-    PyObject* values[5] = {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  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
-        CYTHON_FALLTHROUGH;
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 3341, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 3341, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3341, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("MFI", 0, 4, 5, 1); __PYX_ERR(2, 3704, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("MFI", 0, 4, 5, 2); __PYX_ERR(2, 3704, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_volume)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("MFI", 0, 4, 5, 3); __PYX_ERR(2, 3704, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  4:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod);
-          if (value) { values[4] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "MFI") < 0)) __PYX_ERR(2, 3704, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "LINEARREG_ANGLE", 0) < (0)) __PYX_ERR(4, 3341, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("LINEARREG_ANGLE", 0, 1, 2, i); __PYX_ERR(4, 3341, __pyx_L3_error) }
       }
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 3341, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3341, __pyx_L3_error)
         break;
         default: goto __pyx_L5_argtuple_error;
       }
     }
-    __pyx_v_high = ((PyArrayObject *)values[0]);
-    __pyx_v_low = ((PyArrayObject *)values[1]);
-    __pyx_v_close = ((PyArrayObject *)values[2]);
-    __pyx_v_volume = ((PyArrayObject *)values[3]);
-    if (values[4]) {
-      __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[4]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 3704, __pyx_L3_error)
+    __pyx_v_real = ((PyArrayObject *)values[0]);
+    if (values[1]) {
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3343, __pyx_L3_error)
     } else {
-      __pyx_v_timeperiod = ((int)-2147483648);
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
     }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("MFI", 0, 4, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 3704, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("LINEARREG_ANGLE", 0, 1, 2, __pyx_nargs); __PYX_ERR(4, 3341, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.MFI", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.LINEARREG_ANGLE", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(2, 3704, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(2, 3704, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(2, 3704, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_volume), __pyx_ptype_5numpy_ndarray, 0, "volume", 0))) __PYX_ERR(2, 3704, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_240MFI(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_volume, __pyx_v_timeperiod);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 3343, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_218LINEARREG_ANGLE(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_240MFI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, PyArrayObject *__pyx_v_volume, int __pyx_v_timeperiod) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_218LINEARREG_ANGLE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -24145,57 +28843,40 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_240MFI(CYTHON_UNUSED PyObject *__pyx_s
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  npy_intp __pyx_t_2;
-  npy_int __pyx_t_3;
-  __Pyx_RefNannySetupContext("MFI", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_high);
-  __Pyx_INCREF((PyObject *)__pyx_v_low);
-  __Pyx_INCREF((PyObject *)__pyx_v_close);
-  __Pyx_INCREF((PyObject *)__pyx_v_volume);
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3723, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3724, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3725, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
+  npy_int __pyx_t_2;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("LINEARREG_ANGLE", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_volume)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3726, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3362, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_volume, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_volume); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(2, 3727, __pyx_L1_error)
-  __pyx_v_length = __pyx_t_2;
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
-  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_v_high->data), ((double *)__pyx_v_low->data), ((double *)__pyx_v_close->data), ((double *)__pyx_v_volume->data)); if (unlikely(__pyx_t_3 == ((npy_int)-1))) __PYX_ERR(2, 3728, __pyx_L1_error)
-  __pyx_v_begidx = __pyx_t_3;
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3364, __pyx_L1_error)
+  __pyx_v_begidx = __pyx_t_2;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_MFI_Lookback(__pyx_v_timeperiod));
+  __pyx_v_lookback = (__pyx_v_begidx + TA_LINEARREG_ANGLE_Lookback(__pyx_v_timeperiod));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3731, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3367, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_MFI(0, __pyx_v_endidx, (((double *)__pyx_v_high->data) + __pyx_v_begidx), (((double *)__pyx_v_low->data) + __pyx_v_begidx), (((double *)__pyx_v_close->data) + __pyx_v_begidx), (((double *)__pyx_v_volume->data) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_v_outreal->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_LINEARREG_ANGLE(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_MFI, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3733, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_LINEARREG_ANGLE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3369, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outreal));
+  __Pyx_INCREF((PyObject *)__pyx_v_outreal);
   __pyx_r = ((PyObject *)__pyx_v_outreal);
   goto __pyx_L0;
 
@@ -24203,14 +28884,11 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_240MFI(CYTHON_UNUSED PyObject *__pyx_s
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.MFI", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.LINEARREG_ANGLE", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
-  __Pyx_XDECREF((PyObject *)__pyx_v_high);
-  __Pyx_XDECREF((PyObject *)__pyx_v_low);
-  __Pyx_XDECREF((PyObject *)__pyx_v_close);
-  __Pyx_XDECREF((PyObject *)__pyx_v_volume);
+  __Pyx_XDECREF((PyObject *)__pyx_v_real);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -24218,81 +28896,119 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_240MFI(CYTHON_UNUSED PyObject *__pyx_s
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_243MIDPOINT(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_242MIDPOINT[] = " MIDPOINT(real[, timeperiod=?])\n\n    MidPoint over period (Overlap Studies)\n\n    Inputs:\n        real: (any ndarray)\n    Parameters:\n        timeperiod: 14\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_243MIDPOINT = {"MIDPOINT", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_243MIDPOINT, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_242MIDPOINT};
-static PyObject *__pyx_pw_5talib_7_ta_lib_243MIDPOINT(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_221LINEARREG_INTERCEPT(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_220LINEARREG_INTERCEPT, "LINEARREG_INTERCEPT(ndarray real, int timeperiod=-0x80000000)\n\nLINEARREG_INTERCEPT(real[, timeperiod=?])\n\nLinear Regression Intercept (Statistic Functions)\n\nInputs:\n    real: (any ndarray)\nParameters:\n    timeperiod: 14\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_221LINEARREG_INTERCEPT = {"LINEARREG_INTERCEPT", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_221LINEARREG_INTERCEPT, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_220LINEARREG_INTERCEPT};
+static PyObject *__pyx_pw_5talib_7_ta_lib_221LINEARREG_INTERCEPT(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_real = 0;
   int __pyx_v_timeperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("MIDPOINT (wrapper)", 0);
+  __Pyx_RefNannySetupContext("LINEARREG_INTERCEPT (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,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);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 3372, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 3372, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3372, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod);
-          if (value) { values[1] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "MIDPOINT") < 0)) __PYX_ERR(2, 3738, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "LINEARREG_INTERCEPT", 0) < (0)) __PYX_ERR(4, 3372, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("LINEARREG_INTERCEPT", 0, 1, 2, i); __PYX_ERR(4, 3372, __pyx_L3_error) }
       }
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 3372, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3372, __pyx_L3_error)
         break;
         default: goto __pyx_L5_argtuple_error;
       }
     }
     __pyx_v_real = ((PyArrayObject *)values[0]);
     if (values[1]) {
-      __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 3738, __pyx_L3_error)
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3374, __pyx_L3_error)
     } else {
-      __pyx_v_timeperiod = ((int)-2147483648);
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
     }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("MIDPOINT", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 3738, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("LINEARREG_INTERCEPT", 0, 1, 2, __pyx_nargs); __PYX_ERR(4, 3372, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.MIDPOINT", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.LINEARREG_INTERCEPT", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(2, 3738, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_242MIDPOINT(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 3374, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_220LINEARREG_INTERCEPT(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_242MIDPOINT(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_220LINEARREG_INTERCEPT(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -24305,36 +29021,39 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_242MIDPOINT(CYTHON_UNUSED PyObject *__
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_int __pyx_t_2;
-  __Pyx_RefNannySetupContext("MIDPOINT", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("LINEARREG_INTERCEPT", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3757, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3393, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_v_real->data)); if (unlikely(__pyx_t_2 == ((npy_int)-1))) __PYX_ERR(2, 3759, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3395, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_2;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_MIDPOINT_Lookback(__pyx_v_timeperiod));
+  __pyx_v_lookback = (__pyx_v_begidx + TA_LINEARREG_INTERCEPT_Lookback(__pyx_v_timeperiod));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3762, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3398, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_MIDPOINT(0, __pyx_v_endidx, (((double *)__pyx_v_real->data) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_v_outreal->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_LINEARREG_INTERCEPT(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_MIDPOINT, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3764, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_LINEARREG_INTERCEPT, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3400, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outreal));
+  __Pyx_INCREF((PyObject *)__pyx_v_outreal);
   __pyx_r = ((PyObject *)__pyx_v_outreal);
   goto __pyx_L0;
 
@@ -24342,7 +29061,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_242MIDPOINT(CYTHON_UNUSED PyObject *__
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.MIDPOINT", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.LINEARREG_INTERCEPT", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
@@ -24354,93 +29073,119 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_242MIDPOINT(CYTHON_UNUSED PyObject *__
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_245MIDPRICE(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_244MIDPRICE[] = " MIDPRICE(high, low[, timeperiod=?])\n\n    Midpoint Price over period (Overlap Studies)\n\n    Inputs:\n        prices: ['high', 'low']\n    Parameters:\n        timeperiod: 14\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_245MIDPRICE = {"MIDPRICE", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_245MIDPRICE, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_244MIDPRICE};
-static PyObject *__pyx_pw_5talib_7_ta_lib_245MIDPRICE(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_high = 0;
-  PyArrayObject *__pyx_v_low = 0;
+static PyObject *__pyx_pw_5talib_7_ta_lib_223LINEARREG_SLOPE(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_222LINEARREG_SLOPE, "LINEARREG_SLOPE(ndarray real, int timeperiod=-0x80000000)\n\nLINEARREG_SLOPE(real[, timeperiod=?])\n\nLinear Regression Slope (Statistic Functions)\n\nInputs:\n    real: (any ndarray)\nParameters:\n    timeperiod: 14\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_223LINEARREG_SLOPE = {"LINEARREG_SLOPE", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_223LINEARREG_SLOPE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_222LINEARREG_SLOPE};
+static PyObject *__pyx_pw_5talib_7_ta_lib_223LINEARREG_SLOPE(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_real = 0;
   int __pyx_v_timeperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("MIDPRICE (wrapper)", 0);
+  __Pyx_RefNannySetupContext("LINEARREG_SLOPE (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_timeperiod,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);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 3403, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 3403, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3403, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("MIDPRICE", 0, 2, 3, 1); __PYX_ERR(2, 3769, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod);
-          if (value) { values[2] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "MIDPRICE") < 0)) __PYX_ERR(2, 3769, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "LINEARREG_SLOPE", 0) < (0)) __PYX_ERR(4, 3403, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("LINEARREG_SLOPE", 0, 1, 2, i); __PYX_ERR(4, 3403, __pyx_L3_error) }
       }
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 3403, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3403, __pyx_L3_error)
         break;
         default: goto __pyx_L5_argtuple_error;
       }
     }
-    __pyx_v_high = ((PyArrayObject *)values[0]);
-    __pyx_v_low = ((PyArrayObject *)values[1]);
-    if (values[2]) {
-      __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 3769, __pyx_L3_error)
+    __pyx_v_real = ((PyArrayObject *)values[0]);
+    if (values[1]) {
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3405, __pyx_L3_error)
     } else {
-      __pyx_v_timeperiod = ((int)-2147483648);
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
     }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("MIDPRICE", 0, 2, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 3769, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("LINEARREG_SLOPE", 0, 1, 2, __pyx_nargs); __PYX_ERR(4, 3403, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.MIDPRICE", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.LINEARREG_SLOPE", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(2, 3769, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(2, 3769, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_244MIDPRICE(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_timeperiod);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 3405, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_222LINEARREG_SLOPE(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_244MIDPRICE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, int __pyx_v_timeperiod) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_222LINEARREG_SLOPE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -24452,45 +29197,40 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_244MIDPRICE(CYTHON_UNUSED PyObject *__
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  npy_intp __pyx_t_2;
-  npy_int __pyx_t_3;
-  __Pyx_RefNannySetupContext("MIDPRICE", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_high);
-  __Pyx_INCREF((PyObject *)__pyx_v_low);
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3788, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
+  npy_int __pyx_t_2;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("LINEARREG_SLOPE", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3789, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3424, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_high, __pyx_v_low); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(2, 3790, __pyx_L1_error)
-  __pyx_v_length = __pyx_t_2;
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
-  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx2(__pyx_v_length, ((double *)__pyx_v_high->data), ((double *)__pyx_v_low->data)); if (unlikely(__pyx_t_3 == ((npy_int)-1))) __PYX_ERR(2, 3791, __pyx_L1_error)
-  __pyx_v_begidx = __pyx_t_3;
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3426, __pyx_L1_error)
+  __pyx_v_begidx = __pyx_t_2;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_MIDPRICE_Lookback(__pyx_v_timeperiod));
+  __pyx_v_lookback = (__pyx_v_begidx + TA_LINEARREG_SLOPE_Lookback(__pyx_v_timeperiod));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3794, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3429, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_MIDPRICE(0, __pyx_v_endidx, (((double *)__pyx_v_high->data) + __pyx_v_begidx), (((double *)__pyx_v_low->data) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_v_outreal->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_LINEARREG_SLOPE(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_MIDPRICE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3796, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_LINEARREG_SLOPE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3431, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outreal));
+  __Pyx_INCREF((PyObject *)__pyx_v_outreal);
   __pyx_r = ((PyObject *)__pyx_v_outreal);
   goto __pyx_L0;
 
@@ -24498,12 +29238,11 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_244MIDPRICE(CYTHON_UNUSED PyObject *__
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.MIDPRICE", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.LINEARREG_SLOPE", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
-  __Pyx_XDECREF((PyObject *)__pyx_v_high);
-  __Pyx_XDECREF((PyObject *)__pyx_v_low);
+  __Pyx_XDECREF((PyObject *)__pyx_v_real);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -24511,81 +29250,102 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_244MIDPRICE(CYTHON_UNUSED PyObject *__
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_247MIN(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_246MIN[] = " MIN(real[, timeperiod=?])\n\n    Lowest value over a specified period (Math Operators)\n\n    Inputs:\n        real: (any ndarray)\n    Parameters:\n        timeperiod: 30\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_247MIN = {"MIN", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_247MIN, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_246MIN};
-static PyObject *__pyx_pw_5talib_7_ta_lib_247MIN(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_225LN(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_224LN, "LN(ndarray real)\n\nLN(real)\n\nVector Log Natural (Math Transform)\n\nInputs:\n    real: (any ndarray)\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_225LN = {"LN", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_225LN, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_224LN};
+static PyObject *__pyx_pw_5talib_7_ta_lib_225LN(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_real = 0;
-  int __pyx_v_timeperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("MIN (wrapper)", 0);
+  __Pyx_RefNannySetupContext("LN (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,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);
-        CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 3434, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3434, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod);
-          if (value) { values[1] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "MIN") < 0)) __PYX_ERR(2, 3801, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "LN", 0) < (0)) __PYX_ERR(4, 3434, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("LN", 1, 1, 1, i); __PYX_ERR(4, 3434, __pyx_L3_error) }
       }
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-        break;
-        default: goto __pyx_L5_argtuple_error;
-      }
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3434, __pyx_L3_error)
     }
     __pyx_v_real = ((PyArrayObject *)values[0]);
-    if (values[1]) {
-      __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 3801, __pyx_L3_error)
-    } else {
-      __pyx_v_timeperiod = ((int)-2147483648);
-    }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("MIN", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 3801, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("LN", 1, 1, 1, __pyx_nargs); __PYX_ERR(4, 3434, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.MIN", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.LN", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(2, 3801, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_246MIN(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 3436, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_224LN(__pyx_self, __pyx_v_real);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_246MIN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_224LN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -24598,36 +29358,39 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_246MIN(CYTHON_UNUSED PyObject *__pyx_s
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_int __pyx_t_2;
-  __Pyx_RefNannySetupContext("MIN", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("LN", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3820, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3453, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_v_real->data)); if (unlikely(__pyx_t_2 == ((npy_int)-1))) __PYX_ERR(2, 3822, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3455, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_2;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_MIN_Lookback(__pyx_v_timeperiod));
+  __pyx_v_lookback = (__pyx_v_begidx + TA_LN_Lookback());
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3825, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3458, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_MIN(0, __pyx_v_endidx, (((double *)__pyx_v_real->data) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_v_outreal->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_LN(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_MIN, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3827, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_LN, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3460, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outreal));
+  __Pyx_INCREF((PyObject *)__pyx_v_outreal);
   __pyx_r = ((PyObject *)__pyx_v_outreal);
   goto __pyx_L0;
 
@@ -24635,7 +29398,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_246MIN(CYTHON_UNUSED PyObject *__pyx_s
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.MIN", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.LN", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
@@ -24647,81 +29410,102 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_246MIN(CYTHON_UNUSED PyObject *__pyx_s
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_249MININDEX(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_248MININDEX[] = " MININDEX(real[, timeperiod=?])\n\n    Index of lowest value over a specified period (Math Operators)\n\n    Inputs:\n        real: (any ndarray)\n    Parameters:\n        timeperiod: 30\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_249MININDEX = {"MININDEX", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_249MININDEX, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_248MININDEX};
-static PyObject *__pyx_pw_5talib_7_ta_lib_249MININDEX(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_227LOG10(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_226LOG10, "LOG10(ndarray real)\n\nLOG10(real)\n\nVector Log10 (Math Transform)\n\nInputs:\n    real: (any ndarray)\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_227LOG10 = {"LOG10", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_227LOG10, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_226LOG10};
+static PyObject *__pyx_pw_5talib_7_ta_lib_227LOG10(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_real = 0;
-  int __pyx_v_timeperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("MININDEX (wrapper)", 0);
+  __Pyx_RefNannySetupContext("LOG10 (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,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);
-        CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 3463, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3463, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod);
-          if (value) { values[1] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "MININDEX") < 0)) __PYX_ERR(2, 3832, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "LOG10", 0) < (0)) __PYX_ERR(4, 3463, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("LOG10", 1, 1, 1, i); __PYX_ERR(4, 3463, __pyx_L3_error) }
       }
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-        break;
-        default: goto __pyx_L5_argtuple_error;
-      }
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3463, __pyx_L3_error)
     }
     __pyx_v_real = ((PyArrayObject *)values[0]);
-    if (values[1]) {
-      __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 3832, __pyx_L3_error)
-    } else {
-      __pyx_v_timeperiod = ((int)-2147483648);
-    }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("MININDEX", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 3832, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("LOG10", 1, 1, 1, __pyx_nargs); __PYX_ERR(4, 3463, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.MININDEX", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.LOG10", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(2, 3832, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_248MININDEX(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 3465, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_226LOG10(__pyx_self, __pyx_v_real);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_248MININDEX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_226LOG10(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -24729,52 +29513,55 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_248MININDEX(CYTHON_UNUSED PyObject *__
   TA_RetCode __pyx_v_retCode;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  PyArrayObject *__pyx_v_outinteger = 0;
+  PyArrayObject *__pyx_v_outreal = 0;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_int __pyx_t_2;
-  __Pyx_RefNannySetupContext("MININDEX", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("LOG10", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3851, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3482, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_v_real->data)); if (unlikely(__pyx_t_2 == ((npy_int)-1))) __PYX_ERR(2, 3853, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3484, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_2;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_MININDEX_Lookback(__pyx_v_timeperiod));
+  __pyx_v_lookback = (__pyx_v_begidx + TA_LOG10_Lookback());
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3856, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3487, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1);
+  __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_MININDEX(0, __pyx_v_endidx, (((double *)__pyx_v_real->data) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_v_outinteger->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_LOG10(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_MININDEX, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3858, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_LOG10, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3489, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outinteger));
-  __pyx_r = ((PyObject *)__pyx_v_outinteger);
+  __Pyx_INCREF((PyObject *)__pyx_v_outreal);
+  __pyx_r = ((PyObject *)__pyx_v_outreal);
   goto __pyx_L0;
 
 
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.MININDEX", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.LOG10", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_outinteger);
+  __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
   __Pyx_XDECREF((PyObject *)__pyx_v_real);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
@@ -24783,81 +29570,133 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_248MININDEX(CYTHON_UNUSED PyObject *__
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_251MINMAX(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_250MINMAX[] = " MINMAX(real[, timeperiod=?])\n\n    Lowest and highest values over a specified period (Math Operators)\n\n    Inputs:\n        real: (any ndarray)\n    Parameters:\n        timeperiod: 30\n    Outputs:\n        min\n        max\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_251MINMAX = {"MINMAX", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_251MINMAX, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_250MINMAX};
-static PyObject *__pyx_pw_5talib_7_ta_lib_251MINMAX(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_229MA(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_228MA, "MA(ndarray real, int timeperiod=-0x80000000, int matype=0)\n\nMA(real[, timeperiod=?, matype=?])\n\nMoving average (Overlap Studies)\n\nInputs:\n    real: (any ndarray)\nParameters:\n    timeperiod: 30\n    matype: 0 (Simple Moving Average)\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_229MA = {"MA", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_229MA, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_228MA};
+static PyObject *__pyx_pw_5talib_7_ta_lib_229MA(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_real = 0;
   int __pyx_v_timeperiod;
+  int __pyx_v_matype;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[3] = {0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("MINMAX (wrapper)", 0);
+  __Pyx_RefNannySetupContext("MA (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,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);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,&__pyx_mstate_global->__pyx_n_u_matype,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 3492, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 3492, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 3492, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3492, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod);
-          if (value) { values[1] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "MINMAX") < 0)) __PYX_ERR(2, 3863, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "MA", 0) < (0)) __PYX_ERR(4, 3492, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("MA", 0, 1, 3, i); __PYX_ERR(4, 3492, __pyx_L3_error) }
       }
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      switch (__pyx_nargs) {
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 3492, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 3492, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3492, __pyx_L3_error)
         break;
         default: goto __pyx_L5_argtuple_error;
       }
     }
     __pyx_v_real = ((PyArrayObject *)values[0]);
     if (values[1]) {
-      __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 3863, __pyx_L3_error)
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3494, __pyx_L3_error)
+    } else {
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
+    }
+    if (values[2]) {
+      __pyx_v_matype = __Pyx_PyLong_As_int(values[2]); if (unlikely((__pyx_v_matype == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3494, __pyx_L3_error)
     } else {
-      __pyx_v_timeperiod = ((int)-2147483648);
+      __pyx_v_matype = ((int)((int)0));
     }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("MINMAX", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 3863, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("MA", 0, 1, 3, __pyx_nargs); __PYX_ERR(4, 3492, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.MINMAX", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.MA", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(2, 3863, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_250MINMAX(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 3494, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_228MA(__pyx_self, __pyx_v_real, __pyx_v_timeperiod, __pyx_v_matype);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_250MINMAX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_228MA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod, int __pyx_v_matype) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -24865,67 +29704,55 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_250MINMAX(CYTHON_UNUSED PyObject *__py
   TA_RetCode __pyx_v_retCode;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  PyArrayObject *__pyx_v_outmin = 0;
-  PyArrayObject *__pyx_v_outmax = 0;
+  PyArrayObject *__pyx_v_outreal = 0;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_int __pyx_t_2;
-  __Pyx_RefNannySetupContext("MINMAX", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("MA", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3884, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3514, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_v_real->data)); if (unlikely(__pyx_t_2 == ((npy_int)-1))) __PYX_ERR(2, 3886, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3516, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_2;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_MINMAX_Lookback(__pyx_v_timeperiod));
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3889, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_v_outmin = ((PyArrayObject *)__pyx_t_1);
-  __pyx_t_1 = 0;
+  __pyx_v_lookback = (__pyx_v_begidx + TA_MA_Lookback(__pyx_v_timeperiod, __pyx_v_matype));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3890, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3519, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_v_outmax = ((PyArrayObject *)__pyx_t_1);
+  __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_MINMAX(0, __pyx_v_endidx, (((double *)__pyx_v_real->data) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_v_outmin->data) + __pyx_v_lookback), (((double *)__pyx_v_outmax->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_MA(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), __pyx_v_timeperiod, __pyx_v_matype, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_MINMAX, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3892, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_MA, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3521, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3893, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outmin));
-  __Pyx_GIVEREF(((PyObject *)__pyx_v_outmin));
-  PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_outmin));
-  __Pyx_INCREF(((PyObject *)__pyx_v_outmax));
-  __Pyx_GIVEREF(((PyObject *)__pyx_v_outmax));
-  PyTuple_SET_ITEM(__pyx_t_1, 1, ((PyObject *)__pyx_v_outmax));
-  __pyx_r = __pyx_t_1;
-  __pyx_t_1 = 0;
+  __Pyx_INCREF((PyObject *)__pyx_v_outreal);
+  __pyx_r = ((PyObject *)__pyx_v_outreal);
   goto __pyx_L0;
 
 
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.MINMAX", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.MA", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_outmin);
-  __Pyx_XDECREF((PyObject *)__pyx_v_outmax);
+  __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
   __Pyx_XDECREF((PyObject *)__pyx_v_real);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
@@ -24934,81 +29761,147 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_250MINMAX(CYTHON_UNUSED PyObject *__py
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_253MINMAXINDEX(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_252MINMAXINDEX[] = " MINMAXINDEX(real[, timeperiod=?])\n\n    Indexes of lowest and highest values over a specified period (Math Operators)\n\n    Inputs:\n        real: (any ndarray)\n    Parameters:\n        timeperiod: 30\n    Outputs:\n        minidx\n        maxidx\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_253MINMAXINDEX = {"MINMAXINDEX", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_253MINMAXINDEX, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_252MINMAXINDEX};
-static PyObject *__pyx_pw_5talib_7_ta_lib_253MINMAXINDEX(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_231MACD(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_230MACD, "MACD(ndarray real, int fastperiod=-0x80000000, int slowperiod=-0x80000000, int signalperiod=-0x80000000)\n\nMACD(real[, fastperiod=?, slowperiod=?, signalperiod=?])\n\nMoving Average Convergence/Divergence (Momentum Indicators)\n\nInputs:\n    real: (any ndarray)\nParameters:\n    fastperiod: 12\n    slowperiod: 26\n    signalperiod: 9\nOutputs:\n    macd\n    macdsignal\n    macdhist");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_231MACD = {"MACD", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_231MACD, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_230MACD};
+static PyObject *__pyx_pw_5talib_7_ta_lib_231MACD(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_real = 0;
-  int __pyx_v_timeperiod;
+  int __pyx_v_fastperiod;
+  int __pyx_v_slowperiod;
+  int __pyx_v_signalperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("MINMAXINDEX (wrapper)", 0);
+  __Pyx_RefNannySetupContext("MACD (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,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);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_fastperiod,&__pyx_mstate_global->__pyx_n_u_slowperiod,&__pyx_mstate_global->__pyx_n_u_signalperiod,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 3524, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 3524, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 3524, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  0: break;
-        default: goto __pyx_L5_argtuple_error;
-      }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 3524, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  1:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod);
-          if (value) { values[1] = value; kw_args--; }
-        }
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3524, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
       }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "MINMAXINDEX") < 0)) __PYX_ERR(2, 3897, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "MACD", 0) < (0)) __PYX_ERR(4, 3524, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("MACD", 0, 1, 4, i); __PYX_ERR(4, 3524, __pyx_L3_error) }
       }
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 3524, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 3524, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 3524, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3524, __pyx_L3_error)
         break;
         default: goto __pyx_L5_argtuple_error;
       }
     }
     __pyx_v_real = ((PyArrayObject *)values[0]);
     if (values[1]) {
-      __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 3897, __pyx_L3_error)
+      __pyx_v_fastperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_fastperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3526, __pyx_L3_error)
+    } else {
+      __pyx_v_fastperiod = ((int)((int)-2147483648));
+    }
+    if (values[2]) {
+      __pyx_v_slowperiod = __Pyx_PyLong_As_int(values[2]); if (unlikely((__pyx_v_slowperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3526, __pyx_L3_error)
+    } else {
+      __pyx_v_slowperiod = ((int)((int)-2147483648));
+    }
+    if (values[3]) {
+      __pyx_v_signalperiod = __Pyx_PyLong_As_int(values[3]); if (unlikely((__pyx_v_signalperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3526, __pyx_L3_error)
     } else {
-      __pyx_v_timeperiod = ((int)-2147483648);
+      __pyx_v_signalperiod = ((int)((int)-2147483648));
     }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("MINMAXINDEX", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 3897, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("MACD", 0, 1, 4, __pyx_nargs); __PYX_ERR(4, 3524, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.MINMAXINDEX", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.MACD", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(2, 3897, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_252MINMAXINDEX(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 3526, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_230MACD(__pyx_self, __pyx_v_real, __pyx_v_fastperiod, __pyx_v_slowperiod, __pyx_v_signalperiod);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_252MINMAXINDEX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_230MACD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_fastperiod, int __pyx_v_slowperiod, int __pyx_v_signalperiod) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -25016,54 +29909,66 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_252MINMAXINDEX(CYTHON_UNUSED PyObject
   TA_RetCode __pyx_v_retCode;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  PyArrayObject *__pyx_v_outminidx = 0;
-  PyArrayObject *__pyx_v_outmaxidx = 0;
+  PyArrayObject *__pyx_v_outmacd = 0;
+  PyArrayObject *__pyx_v_outmacdsignal = 0;
+  PyArrayObject *__pyx_v_outmacdhist = 0;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_int __pyx_t_2;
-  __Pyx_RefNannySetupContext("MINMAXINDEX", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("MACD", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3918, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3551, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_v_real->data)); if (unlikely(__pyx_t_2 == ((npy_int)-1))) __PYX_ERR(2, 3920, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3553, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_2;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_MINMAXINDEX_Lookback(__pyx_v_timeperiod));
+  __pyx_v_lookback = (__pyx_v_begidx + TA_MACD_Lookback(__pyx_v_fastperiod, __pyx_v_slowperiod, __pyx_v_signalperiod));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3923, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3556, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_v_outminidx = ((PyArrayObject *)__pyx_t_1);
+  __pyx_v_outmacd = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3924, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3557, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_v_outmaxidx = ((PyArrayObject *)__pyx_t_1);
+  __pyx_v_outmacdsignal = ((PyArrayObject *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3558, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_outmacdhist = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_MINMAXINDEX(0, __pyx_v_endidx, (((double *)__pyx_v_real->data) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_v_outminidx->data) + __pyx_v_lookback), (((int *)__pyx_v_outmaxidx->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_MACD(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), __pyx_v_fastperiod, __pyx_v_slowperiod, __pyx_v_signalperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outmacd)) + __pyx_v_lookback), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outmacdsignal)) + __pyx_v_lookback), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outmacdhist)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_MINMAXINDEX, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3926, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_MACD, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3560, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3927, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outminidx));
-  __Pyx_GIVEREF(((PyObject *)__pyx_v_outminidx));
-  PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_outminidx));
-  __Pyx_INCREF(((PyObject *)__pyx_v_outmaxidx));
-  __Pyx_GIVEREF(((PyObject *)__pyx_v_outmaxidx));
-  PyTuple_SET_ITEM(__pyx_t_1, 1, ((PyObject *)__pyx_v_outmaxidx));
+  __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3561, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_INCREF((PyObject *)__pyx_v_outmacd);
+  __Pyx_GIVEREF((PyObject *)__pyx_v_outmacd);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_outmacd)) != (0)) __PYX_ERR(4, 3561, __pyx_L1_error);
+  __Pyx_INCREF((PyObject *)__pyx_v_outmacdsignal);
+  __Pyx_GIVEREF((PyObject *)__pyx_v_outmacdsignal);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, ((PyObject *)__pyx_v_outmacdsignal)) != (0)) __PYX_ERR(4, 3561, __pyx_L1_error);
+  __Pyx_INCREF((PyObject *)__pyx_v_outmacdhist);
+  __Pyx_GIVEREF((PyObject *)__pyx_v_outmacdhist);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, ((PyObject *)__pyx_v_outmacdhist)) != (0)) __PYX_ERR(4, 3561, __pyx_L1_error);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
   goto __pyx_L0;
@@ -25072,11 +29977,12 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_252MINMAXINDEX(CYTHON_UNUSED PyObject
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.MINMAXINDEX", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.MACD", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_outminidx);
-  __Pyx_XDECREF((PyObject *)__pyx_v_outmaxidx);
+  __Pyx_XDECREF((PyObject *)__pyx_v_outmacd);
+  __Pyx_XDECREF((PyObject *)__pyx_v_outmacdsignal);
+  __Pyx_XDECREF((PyObject *)__pyx_v_outmacdhist);
   __Pyx_XDECREF((PyObject *)__pyx_v_real);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
@@ -25085,105 +29991,189 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_252MINMAXINDEX(CYTHON_UNUSED PyObject
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_255MINUS_DI(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_254MINUS_DI[] = " MINUS_DI(high, low, close[, timeperiod=?])\n\n    Minus Directional Indicator (Momentum Indicators)\n\n    Inputs:\n        prices: ['high', 'low', 'close']\n    Parameters:\n        timeperiod: 14\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_255MINUS_DI = {"MINUS_DI", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_255MINUS_DI, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_254MINUS_DI};
-static PyObject *__pyx_pw_5talib_7_ta_lib_255MINUS_DI(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_high = 0;
-  PyArrayObject *__pyx_v_low = 0;
-  PyArrayObject *__pyx_v_close = 0;
-  int __pyx_v_timeperiod;
+static PyObject *__pyx_pw_5talib_7_ta_lib_233MACDEXT(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_232MACDEXT, "MACDEXT(ndarray real, int fastperiod=-0x80000000, int fastmatype=0, int slowperiod=-0x80000000, int slowmatype=0, int signalperiod=-0x80000000, int signalmatype=0)\n\nMACDEXT(real[, fastperiod=?, fastmatype=?, slowperiod=?, slowmatype=?, signalperiod=?, signalmatype=?])\n\nMACD with controllable MA type (Momentum Indicators)\n\nInputs:\n    real: (any ndarray)\nParameters:\n    fastperiod: 12\n    fastmatype: 0\n    slowperiod: 26\n    slowmatype: 0\n    signalperiod: 9\n    signalmatype: 0\nOutputs:\n    macd\n    macdsignal\n    macdhist");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_233MACDEXT = {"MACDEXT", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_233MACDEXT, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_232MACDEXT};
+static PyObject *__pyx_pw_5talib_7_ta_lib_233MACDEXT(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_real = 0;
+  int __pyx_v_fastperiod;
+  int __pyx_v_fastmatype;
+  int __pyx_v_slowperiod;
+  int __pyx_v_slowmatype;
+  int __pyx_v_signalperiod;
+  int __pyx_v_signalmatype;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[7] = {0,0,0,0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("MINUS_DI (wrapper)", 0);
+  __Pyx_RefNannySetupContext("MACDEXT (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,&__pyx_n_s_timeperiod,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_fastperiod,&__pyx_mstate_global->__pyx_n_u_fastmatype,&__pyx_mstate_global->__pyx_n_u_slowperiod,&__pyx_mstate_global->__pyx_n_u_slowmatype,&__pyx_mstate_global->__pyx_n_u_signalperiod,&__pyx_mstate_global->__pyx_n_u_signalmatype,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 3563, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  7:
+        values[6] = __Pyx_ArgRef_FASTCALL(__pyx_args, 6);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(4, 3563, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  6:
+        values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(4, 3563, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  5:
+        values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(4, 3563, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 3563, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 3563, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 3563, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3563, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "MACDEXT", 0) < (0)) __PYX_ERR(4, 3563, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("MACDEXT", 0, 1, 7, i); __PYX_ERR(4, 3563, __pyx_L3_error) }
+      }
+    } else {
+      switch (__pyx_nargs) {
+        case  7:
+        values[6] = __Pyx_ArgRef_FASTCALL(__pyx_args, 6);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(4, 3563, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("MINUS_DI", 0, 3, 4, 1); __PYX_ERR(2, 3931, __pyx_L3_error)
-        }
+        case  6:
+        values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(4, 3563, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("MINUS_DI", 0, 3, 4, 2); __PYX_ERR(2, 3931, __pyx_L3_error)
-        }
+        case  5:
+        values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(4, 3563, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 3563, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  3:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod);
-          if (value) { values[3] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "MINUS_DI") < 0)) __PYX_ERR(2, 3931, __pyx_L3_error)
-      }
-    } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 3563, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 3563, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3563, __pyx_L3_error)
         break;
         default: goto __pyx_L5_argtuple_error;
       }
     }
-    __pyx_v_high = ((PyArrayObject *)values[0]);
-    __pyx_v_low = ((PyArrayObject *)values[1]);
-    __pyx_v_close = ((PyArrayObject *)values[2]);
+    __pyx_v_real = ((PyArrayObject *)values[0]);
+    if (values[1]) {
+      __pyx_v_fastperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_fastperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3565, __pyx_L3_error)
+    } else {
+      __pyx_v_fastperiod = ((int)((int)-2147483648));
+    }
+    if (values[2]) {
+      __pyx_v_fastmatype = __Pyx_PyLong_As_int(values[2]); if (unlikely((__pyx_v_fastmatype == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3565, __pyx_L3_error)
+    } else {
+      __pyx_v_fastmatype = ((int)((int)0));
+    }
     if (values[3]) {
-      __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[3]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 3931, __pyx_L3_error)
+      __pyx_v_slowperiod = __Pyx_PyLong_As_int(values[3]); if (unlikely((__pyx_v_slowperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3565, __pyx_L3_error)
+    } else {
+      __pyx_v_slowperiod = ((int)((int)-2147483648));
+    }
+    if (values[4]) {
+      __pyx_v_slowmatype = __Pyx_PyLong_As_int(values[4]); if (unlikely((__pyx_v_slowmatype == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3565, __pyx_L3_error)
+    } else {
+      __pyx_v_slowmatype = ((int)((int)0));
+    }
+    if (values[5]) {
+      __pyx_v_signalperiod = __Pyx_PyLong_As_int(values[5]); if (unlikely((__pyx_v_signalperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3565, __pyx_L3_error)
+    } else {
+      __pyx_v_signalperiod = ((int)((int)-2147483648));
+    }
+    if (values[6]) {
+      __pyx_v_signalmatype = __Pyx_PyLong_As_int(values[6]); if (unlikely((__pyx_v_signalmatype == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3565, __pyx_L3_error)
     } else {
-      __pyx_v_timeperiod = ((int)-2147483648);
+      __pyx_v_signalmatype = ((int)((int)0));
     }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("MINUS_DI", 0, 3, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 3931, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("MACDEXT", 0, 1, 7, __pyx_nargs); __PYX_ERR(4, 3563, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.MINUS_DI", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.MACDEXT", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(2, 3931, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(2, 3931, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(2, 3931, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_254MINUS_DI(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_timeperiod);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 3565, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_232MACDEXT(__pyx_self, __pyx_v_real, __pyx_v_fastperiod, __pyx_v_fastmatype, __pyx_v_slowperiod, __pyx_v_slowmatype, __pyx_v_signalperiod, __pyx_v_signalmatype);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_254MINUS_DI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_232MACDEXT(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_fastperiod, int __pyx_v_fastmatype, int __pyx_v_slowperiod, int __pyx_v_slowmatype, int __pyx_v_signalperiod, int __pyx_v_signalmatype) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -25191,69 +30181,81 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_254MINUS_DI(CYTHON_UNUSED PyObject *__
   TA_RetCode __pyx_v_retCode;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  PyArrayObject *__pyx_v_outreal = 0;
+  PyArrayObject *__pyx_v_outmacd = 0;
+  PyArrayObject *__pyx_v_outmacdsignal = 0;
+  PyArrayObject *__pyx_v_outmacdhist = 0;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  npy_intp __pyx_t_2;
-  npy_int __pyx_t_3;
-  __Pyx_RefNannySetupContext("MINUS_DI", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_high);
-  __Pyx_INCREF((PyObject *)__pyx_v_low);
-  __Pyx_INCREF((PyObject *)__pyx_v_close);
+  npy_int __pyx_t_2;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("MACDEXT", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3950, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3593, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3951, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3952, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3595, __pyx_L1_error)
+  __pyx_v_begidx = __pyx_t_2;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(2, 3953, __pyx_L1_error)
-  __pyx_v_length = __pyx_t_2;
+  __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx3(__pyx_v_length, ((double *)__pyx_v_high->data), ((double *)__pyx_v_low->data), ((double *)__pyx_v_close->data)); if (unlikely(__pyx_t_3 == ((npy_int)-1))) __PYX_ERR(2, 3954, __pyx_L1_error)
-  __pyx_v_begidx = __pyx_t_3;
+  __pyx_v_lookback = (__pyx_v_begidx + TA_MACDEXT_Lookback(__pyx_v_fastperiod, __pyx_v_fastmatype, __pyx_v_slowperiod, __pyx_v_slowmatype, __pyx_v_signalperiod, __pyx_v_signalmatype));
 
-  __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3598, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_outmacd = ((PyArrayObject *)__pyx_t_1);
+  __pyx_t_1 = 0;
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_MINUS_DI_Lookback(__pyx_v_timeperiod));
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3599, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_outmacdsignal = ((PyArrayObject *)__pyx_t_1);
+  __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3957, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3600, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
+  __pyx_v_outmacdhist = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_MINUS_DI(0, __pyx_v_endidx, (((double *)__pyx_v_high->data) + __pyx_v_begidx), (((double *)__pyx_v_low->data) + __pyx_v_begidx), (((double *)__pyx_v_close->data) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_v_outreal->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_MACDEXT(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), __pyx_v_fastperiod, __pyx_v_fastmatype, __pyx_v_slowperiod, __pyx_v_slowmatype, __pyx_v_signalperiod, __pyx_v_signalmatype, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outmacd)) + __pyx_v_lookback), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outmacdsignal)) + __pyx_v_lookback), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outmacdhist)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_MINUS_DI, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3959, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_MACDEXT, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3602, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outreal));
-  __pyx_r = ((PyObject *)__pyx_v_outreal);
+  __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3603, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_INCREF((PyObject *)__pyx_v_outmacd);
+  __Pyx_GIVEREF((PyObject *)__pyx_v_outmacd);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_outmacd)) != (0)) __PYX_ERR(4, 3603, __pyx_L1_error);
+  __Pyx_INCREF((PyObject *)__pyx_v_outmacdsignal);
+  __Pyx_GIVEREF((PyObject *)__pyx_v_outmacdsignal);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, ((PyObject *)__pyx_v_outmacdsignal)) != (0)) __PYX_ERR(4, 3603, __pyx_L1_error);
+  __Pyx_INCREF((PyObject *)__pyx_v_outmacdhist);
+  __Pyx_GIVEREF((PyObject *)__pyx_v_outmacdhist);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, ((PyObject *)__pyx_v_outmacdhist)) != (0)) __PYX_ERR(4, 3603, __pyx_L1_error);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
   goto __pyx_L0;
 
 
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.MINUS_DI", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.MACDEXT", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
-  __Pyx_XDECREF((PyObject *)__pyx_v_high);
-  __Pyx_XDECREF((PyObject *)__pyx_v_low);
-  __Pyx_XDECREF((PyObject *)__pyx_v_close);
+  __Pyx_XDECREF((PyObject *)__pyx_v_outmacd);
+  __Pyx_XDECREF((PyObject *)__pyx_v_outmacdsignal);
+  __Pyx_XDECREF((PyObject *)__pyx_v_outmacdhist);
+  __Pyx_XDECREF((PyObject *)__pyx_v_real);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -25261,93 +30263,119 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_254MINUS_DI(CYTHON_UNUSED PyObject *__
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_257MINUS_DM(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_256MINUS_DM[] = " MINUS_DM(high, low[, timeperiod=?])\n\n    Minus Directional Movement (Momentum Indicators)\n\n    Inputs:\n        prices: ['high', 'low']\n    Parameters:\n        timeperiod: 14\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_257MINUS_DM = {"MINUS_DM", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_257MINUS_DM, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_256MINUS_DM};
-static PyObject *__pyx_pw_5talib_7_ta_lib_257MINUS_DM(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_high = 0;
-  PyArrayObject *__pyx_v_low = 0;
-  int __pyx_v_timeperiod;
+static PyObject *__pyx_pw_5talib_7_ta_lib_235MACDFIX(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_234MACDFIX, "MACDFIX(ndarray real, int signalperiod=-0x80000000)\n\nMACDFIX(real[, signalperiod=?])\n\nMoving Average Convergence/Divergence Fix 12/26 (Momentum Indicators)\n\nInputs:\n    real: (any ndarray)\nParameters:\n    signalperiod: 9\nOutputs:\n    macd\n    macdsignal\n    macdhist");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_235MACDFIX = {"MACDFIX", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_235MACDFIX, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_234MACDFIX};
+static PyObject *__pyx_pw_5talib_7_ta_lib_235MACDFIX(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_real = 0;
+  int __pyx_v_signalperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("MINUS_DM (wrapper)", 0);
+  __Pyx_RefNannySetupContext("MACDFIX (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_timeperiod,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);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_signalperiod,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 3605, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 3605, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3605, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("MINUS_DM", 0, 2, 3, 1); __PYX_ERR(2, 3964, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod);
-          if (value) { values[2] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "MINUS_DM") < 0)) __PYX_ERR(2, 3964, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "MACDFIX", 0) < (0)) __PYX_ERR(4, 3605, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("MACDFIX", 0, 1, 2, i); __PYX_ERR(4, 3605, __pyx_L3_error) }
       }
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 3605, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3605, __pyx_L3_error)
         break;
         default: goto __pyx_L5_argtuple_error;
       }
     }
-    __pyx_v_high = ((PyArrayObject *)values[0]);
-    __pyx_v_low = ((PyArrayObject *)values[1]);
-    if (values[2]) {
-      __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 3964, __pyx_L3_error)
+    __pyx_v_real = ((PyArrayObject *)values[0]);
+    if (values[1]) {
+      __pyx_v_signalperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_signalperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3607, __pyx_L3_error)
     } else {
-      __pyx_v_timeperiod = ((int)-2147483648);
+      __pyx_v_signalperiod = ((int)((int)-2147483648));
     }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("MINUS_DM", 0, 2, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 3964, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("MACDFIX", 0, 1, 2, __pyx_nargs); __PYX_ERR(4, 3605, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.MINUS_DM", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.MACDFIX", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(2, 3964, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(2, 3964, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_256MINUS_DM(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_timeperiod);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 3607, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_234MACDFIX(__pyx_self, __pyx_v_real, __pyx_v_signalperiod);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_256MINUS_DM(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, int __pyx_v_timeperiod) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_234MACDFIX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_signalperiod) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -25355,62 +30383,81 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_256MINUS_DM(CYTHON_UNUSED PyObject *__
   TA_RetCode __pyx_v_retCode;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  PyArrayObject *__pyx_v_outreal = 0;
+  PyArrayObject *__pyx_v_outmacd = 0;
+  PyArrayObject *__pyx_v_outmacdsignal = 0;
+  PyArrayObject *__pyx_v_outmacdhist = 0;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  npy_intp __pyx_t_2;
-  npy_int __pyx_t_3;
-  __Pyx_RefNannySetupContext("MINUS_DM", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_high);
-  __Pyx_INCREF((PyObject *)__pyx_v_low);
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3983, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
+  npy_int __pyx_t_2;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("MACDFIX", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3984, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3630, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_high, __pyx_v_low); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(2, 3985, __pyx_L1_error)
-  __pyx_v_length = __pyx_t_2;
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
-  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx2(__pyx_v_length, ((double *)__pyx_v_high->data), ((double *)__pyx_v_low->data)); if (unlikely(__pyx_t_3 == ((npy_int)-1))) __PYX_ERR(2, 3986, __pyx_L1_error)
-  __pyx_v_begidx = __pyx_t_3;
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3632, __pyx_L1_error)
+  __pyx_v_begidx = __pyx_t_2;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_MINUS_DM_Lookback(__pyx_v_timeperiod));
+  __pyx_v_lookback = (__pyx_v_begidx + TA_MACDFIX_Lookback(__pyx_v_signalperiod));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3989, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3635, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
+  __pyx_v_outmacd = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_MINUS_DM(0, __pyx_v_endidx, (((double *)__pyx_v_high->data) + __pyx_v_begidx), (((double *)__pyx_v_low->data) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_v_outreal->data) + __pyx_v_lookback));
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3636, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_outmacdsignal = ((PyArrayObject *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3637, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_outmacdhist = ((PyArrayObject *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  __pyx_v_retCode = TA_MACDFIX(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), __pyx_v_signalperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outmacd)) + __pyx_v_lookback), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outmacdsignal)) + __pyx_v_lookback), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outmacdhist)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_MINUS_DM, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 3991, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_MACDFIX, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3639, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outreal));
-  __pyx_r = ((PyObject *)__pyx_v_outreal);
+  __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3640, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_INCREF((PyObject *)__pyx_v_outmacd);
+  __Pyx_GIVEREF((PyObject *)__pyx_v_outmacd);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_outmacd)) != (0)) __PYX_ERR(4, 3640, __pyx_L1_error);
+  __Pyx_INCREF((PyObject *)__pyx_v_outmacdsignal);
+  __Pyx_GIVEREF((PyObject *)__pyx_v_outmacdsignal);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, ((PyObject *)__pyx_v_outmacdsignal)) != (0)) __PYX_ERR(4, 3640, __pyx_L1_error);
+  __Pyx_INCREF((PyObject *)__pyx_v_outmacdhist);
+  __Pyx_GIVEREF((PyObject *)__pyx_v_outmacdhist);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, ((PyObject *)__pyx_v_outmacdhist)) != (0)) __PYX_ERR(4, 3640, __pyx_L1_error);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
   goto __pyx_L0;
 
 
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.MINUS_DM", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.MACDFIX", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
-  __Pyx_XDECREF((PyObject *)__pyx_v_high);
-  __Pyx_XDECREF((PyObject *)__pyx_v_low);
+  __Pyx_XDECREF((PyObject *)__pyx_v_outmacd);
+  __Pyx_XDECREF((PyObject *)__pyx_v_outmacdsignal);
+  __Pyx_XDECREF((PyObject *)__pyx_v_outmacdhist);
+  __Pyx_XDECREF((PyObject *)__pyx_v_real);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -25418,81 +30465,133 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_256MINUS_DM(CYTHON_UNUSED PyObject *__
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_259MOM(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_258MOM[] = " MOM(real[, timeperiod=?])\n\n    Momentum (Momentum Indicators)\n\n    Inputs:\n        real: (any ndarray)\n    Parameters:\n        timeperiod: 10\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_259MOM = {"MOM", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_259MOM, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_258MOM};
-static PyObject *__pyx_pw_5talib_7_ta_lib_259MOM(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_237MAMA(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_236MAMA, "MAMA(ndarray real, double fastlimit=-4e37, double slowlimit=-4e37)\n\nMAMA(real[, fastlimit=?, slowlimit=?])\n\nMESA Adaptive Moving Average (Overlap Studies)\n\nInputs:\n    real: (any ndarray)\nParameters:\n    fastlimit: 0.5\n    slowlimit: 0.05\nOutputs:\n    mama\n    fama");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_237MAMA = {"MAMA", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_237MAMA, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_236MAMA};
+static PyObject *__pyx_pw_5talib_7_ta_lib_237MAMA(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_real = 0;
-  int __pyx_v_timeperiod;
+  double __pyx_v_fastlimit;
+  double __pyx_v_slowlimit;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[3] = {0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("MOM (wrapper)", 0);
+  __Pyx_RefNannySetupContext("MAMA (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,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);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_fastlimit,&__pyx_mstate_global->__pyx_n_u_slowlimit,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 3642, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 3642, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 3642, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3642, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod);
-          if (value) { values[1] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "MOM") < 0)) __PYX_ERR(2, 3996, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "MAMA", 0) < (0)) __PYX_ERR(4, 3642, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("MAMA", 0, 1, 3, i); __PYX_ERR(4, 3642, __pyx_L3_error) }
       }
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      switch (__pyx_nargs) {
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 3642, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 3642, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3642, __pyx_L3_error)
         break;
         default: goto __pyx_L5_argtuple_error;
       }
     }
     __pyx_v_real = ((PyArrayObject *)values[0]);
     if (values[1]) {
-      __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 3996, __pyx_L3_error)
+      __pyx_v_fastlimit = __Pyx_PyFloat_AsDouble(values[1]); if (unlikely((__pyx_v_fastlimit == (double)-1) && PyErr_Occurred())) __PYX_ERR(4, 3644, __pyx_L3_error)
+    } else {
+      __pyx_v_fastlimit = ((double)((double)-4e37));
+    }
+    if (values[2]) {
+      __pyx_v_slowlimit = __Pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_slowlimit == (double)-1) && PyErr_Occurred())) __PYX_ERR(4, 3644, __pyx_L3_error)
     } else {
-      __pyx_v_timeperiod = ((int)-2147483648);
+      __pyx_v_slowlimit = ((double)((double)-4e37));
     }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("MOM", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 3996, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("MAMA", 0, 1, 3, __pyx_nargs); __PYX_ERR(4, 3642, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.MOM", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.MAMA", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(2, 3996, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_258MOM(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 3644, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_236MAMA(__pyx_self, __pyx_v_real, __pyx_v_fastlimit, __pyx_v_slowlimit);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_258MOM(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_236MAMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, double __pyx_v_fastlimit, double __pyx_v_slowlimit) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -25500,52 +30599,70 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_258MOM(CYTHON_UNUSED PyObject *__pyx_s
   TA_RetCode __pyx_v_retCode;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  PyArrayObject *__pyx_v_outreal = 0;
+  PyArrayObject *__pyx_v_outmama = 0;
+  PyArrayObject *__pyx_v_outfama = 0;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_int __pyx_t_2;
-  __Pyx_RefNannySetupContext("MOM", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("MAMA", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4015, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3666, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_v_real->data)); if (unlikely(__pyx_t_2 == ((npy_int)-1))) __PYX_ERR(2, 4017, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3668, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_2;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_MOM_Lookback(__pyx_v_timeperiod));
+  __pyx_v_lookback = (__pyx_v_begidx + TA_MAMA_Lookback(__pyx_v_fastlimit, __pyx_v_slowlimit));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4020, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3671, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
+  __pyx_v_outmama = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_MOM(0, __pyx_v_endidx, (((double *)__pyx_v_real->data) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_v_outreal->data) + __pyx_v_lookback));
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3672, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_outfama = ((PyArrayObject *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  __pyx_v_retCode = TA_MAMA(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), __pyx_v_fastlimit, __pyx_v_slowlimit, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outmama)) + __pyx_v_lookback), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outfama)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_MOM, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4022, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_MAMA, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3674, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outreal));
-  __pyx_r = ((PyObject *)__pyx_v_outreal);
+  __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3675, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_INCREF((PyObject *)__pyx_v_outmama);
+  __Pyx_GIVEREF((PyObject *)__pyx_v_outmama);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_outmama)) != (0)) __PYX_ERR(4, 3675, __pyx_L1_error);
+  __Pyx_INCREF((PyObject *)__pyx_v_outfama);
+  __Pyx_GIVEREF((PyObject *)__pyx_v_outfama);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, ((PyObject *)__pyx_v_outfama)) != (0)) __PYX_ERR(4, 3675, __pyx_L1_error);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
   goto __pyx_L0;
 
 
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.MOM", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.MAMA", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
+  __Pyx_XDECREF((PyObject *)__pyx_v_outmama);
+  __Pyx_XDECREF((PyObject *)__pyx_v_outfama);
   __Pyx_XDECREF((PyObject *)__pyx_v_real);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
@@ -25554,75 +30671,156 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_258MOM(CYTHON_UNUSED PyObject *__pyx_s
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_261MULT(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_260MULT[] = " MULT(real0, real1)\n\n    Vector Arithmetic Mult (Math Operators)\n\n    Inputs:\n        real0: (any ndarray)\n        real1: (any ndarray)\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_261MULT = {"MULT", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_261MULT, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_260MULT};
-static PyObject *__pyx_pw_5talib_7_ta_lib_261MULT(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_real0 = 0;
-  PyArrayObject *__pyx_v_real1 = 0;
+static PyObject *__pyx_pw_5talib_7_ta_lib_239MAVP(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_238MAVP, "MAVP(ndarray real, ndarray periods, int minperiod=-0x80000000, int maxperiod=-0x80000000, int matype=0)\n\nMAVP(real, periods[, minperiod=?, maxperiod=?, matype=?])\n\nMoving average with variable period (Overlap Studies)\n\nInputs:\n    real: (any ndarray)\n    periods: (any ndarray)\nParameters:\n    minperiod: 2\n    maxperiod: 30\n    matype: 0 (Simple Moving Average)\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_239MAVP = {"MAVP", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_239MAVP, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_238MAVP};
+static PyObject *__pyx_pw_5talib_7_ta_lib_239MAVP(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_real = 0;
+  PyArrayObject *__pyx_v_periods = 0;
+  int __pyx_v_minperiod;
+  int __pyx_v_maxperiod;
+  int __pyx_v_matype;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[5] = {0,0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("MULT (wrapper)", 0);
+  __Pyx_RefNannySetupContext("MAVP (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real0,&__pyx_n_s_real1,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);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_periods,&__pyx_mstate_global->__pyx_n_u_minperiod,&__pyx_mstate_global->__pyx_n_u_maxperiod,&__pyx_mstate_global->__pyx_n_u_matype,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 3677, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  5:
+        values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(4, 3677, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 3677, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  0: break;
-        default: goto __pyx_L5_argtuple_error;
-      }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real0)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 3677, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 3677, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real1)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("MULT", 1, 2, 2, 1); __PYX_ERR(2, 4027, __pyx_L3_error)
-        }
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3677, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
       }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "MULT") < 0)) __PYX_ERR(2, 4027, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "MAVP", 0) < (0)) __PYX_ERR(4, 3677, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("MAVP", 0, 2, 5, i); __PYX_ERR(4, 3677, __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);
+      switch (__pyx_nargs) {
+        case  5:
+        values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(4, 3677, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 3677, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 3677, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 3677, __pyx_L3_error)
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3677, __pyx_L3_error)
+        break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+    }
+    __pyx_v_real = ((PyArrayObject *)values[0]);
+    __pyx_v_periods = ((PyArrayObject *)values[1]);
+    if (values[2]) {
+      __pyx_v_minperiod = __Pyx_PyLong_As_int(values[2]); if (unlikely((__pyx_v_minperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3679, __pyx_L3_error)
+    } else {
+      __pyx_v_minperiod = ((int)((int)-2147483648));
+    }
+    if (values[3]) {
+      __pyx_v_maxperiod = __Pyx_PyLong_As_int(values[3]); if (unlikely((__pyx_v_maxperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3679, __pyx_L3_error)
+    } else {
+      __pyx_v_maxperiod = ((int)((int)-2147483648));
+    }
+    if (values[4]) {
+      __pyx_v_matype = __Pyx_PyLong_As_int(values[4]); if (unlikely((__pyx_v_matype == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3679, __pyx_L3_error)
+    } else {
+      __pyx_v_matype = ((int)((int)0));
     }
-    __pyx_v_real0 = ((PyArrayObject *)values[0]);
-    __pyx_v_real1 = ((PyArrayObject *)values[1]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("MULT", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 4027, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("MAVP", 0, 2, 5, __pyx_nargs); __PYX_ERR(4, 3677, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.MULT", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.MAVP", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real0), __pyx_ptype_5numpy_ndarray, 0, "real0", 0))) __PYX_ERR(2, 4027, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real1), __pyx_ptype_5numpy_ndarray, 0, "real1", 0))) __PYX_ERR(2, 4027, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_260MULT(__pyx_self, __pyx_v_real0, __pyx_v_real1);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 3679, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_periods), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "periods", 0))) __PYX_ERR(4, 3679, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_238MAVP(__pyx_self, __pyx_v_real, __pyx_v_periods, __pyx_v_minperiod, __pyx_v_maxperiod, __pyx_v_matype);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_260MULT(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real0, PyArrayObject *__pyx_v_real1) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_238MAVP(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, PyArrayObject *__pyx_v_periods, int __pyx_v_minperiod, int __pyx_v_maxperiod, int __pyx_v_matype) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -25636,43 +30834,46 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_260MULT(CYTHON_UNUSED PyObject *__pyx_
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
   npy_int __pyx_t_3;
-  __Pyx_RefNannySetupContext("MULT", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_real0);
-  __Pyx_INCREF((PyObject *)__pyx_v_real1);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("MAVP", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_real);
+  __Pyx_INCREF((PyObject *)__pyx_v_periods);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4045, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3701, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_real0, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4046, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_periods)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3702, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_real1, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_periods, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_real0, __pyx_v_real1); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(2, 4047, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_real, __pyx_v_periods); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 3703, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
-  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx2(__pyx_v_length, ((double *)__pyx_v_real0->data), ((double *)__pyx_v_real1->data)); if (unlikely(__pyx_t_3 == ((npy_int)-1))) __PYX_ERR(2, 4048, __pyx_L1_error)
+  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx2(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_periods))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3704, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_3;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_MULT_Lookback());
+  __pyx_v_lookback = (__pyx_v_begidx + TA_MAVP_Lookback(__pyx_v_minperiod, __pyx_v_maxperiod, __pyx_v_matype));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4051, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3707, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_MULT(0, __pyx_v_endidx, (((double *)__pyx_v_real0->data) + __pyx_v_begidx), (((double *)__pyx_v_real1->data) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_v_outreal->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_MAVP(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_periods)) + __pyx_v_begidx), __pyx_v_minperiod, __pyx_v_maxperiod, __pyx_v_matype, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_MULT, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4053, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_MAVP, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3709, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outreal));
+  __Pyx_INCREF((PyObject *)__pyx_v_outreal);
   __pyx_r = ((PyObject *)__pyx_v_outreal);
   goto __pyx_L0;
 
@@ -25680,12 +30881,12 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_260MULT(CYTHON_UNUSED PyObject *__pyx_
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.MULT", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.MAVP", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
-  __Pyx_XDECREF((PyObject *)__pyx_v_real0);
-  __Pyx_XDECREF((PyObject *)__pyx_v_real1);
+  __Pyx_XDECREF((PyObject *)__pyx_v_real);
+  __Pyx_XDECREF((PyObject *)__pyx_v_periods);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -25693,105 +30894,119 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_260MULT(CYTHON_UNUSED PyObject *__pyx_
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_263NATR(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_262NATR[] = " NATR(high, low, close[, timeperiod=?])\n\n    Normalized Average True Range (Volatility Indicators)\n\n    Inputs:\n        prices: ['high', 'low', 'close']\n    Parameters:\n        timeperiod: 14\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_263NATR = {"NATR", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_263NATR, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_262NATR};
-static PyObject *__pyx_pw_5talib_7_ta_lib_263NATR(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_high = 0;
-  PyArrayObject *__pyx_v_low = 0;
-  PyArrayObject *__pyx_v_close = 0;
+static PyObject *__pyx_pw_5talib_7_ta_lib_241MAX(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_240MAX, "MAX(ndarray real, int timeperiod=-0x80000000)\n\nMAX(real[, timeperiod=?])\n\nHighest value over a specified period (Math Operators)\n\nInputs:\n    real: (any ndarray)\nParameters:\n    timeperiod: 30\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_241MAX = {"MAX", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_241MAX, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_240MAX};
+static PyObject *__pyx_pw_5talib_7_ta_lib_241MAX(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_real = 0;
   int __pyx_v_timeperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("NATR (wrapper)", 0);
+  __Pyx_RefNannySetupContext("MAX (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,&__pyx_n_s_timeperiod,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 3712, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 3712, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3712, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("NATR", 0, 3, 4, 1); __PYX_ERR(2, 4058, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("NATR", 0, 3, 4, 2); __PYX_ERR(2, 4058, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod);
-          if (value) { values[3] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "NATR") < 0)) __PYX_ERR(2, 4058, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "MAX", 0) < (0)) __PYX_ERR(4, 3712, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("MAX", 0, 1, 2, i); __PYX_ERR(4, 3712, __pyx_L3_error) }
       }
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 3712, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3712, __pyx_L3_error)
         break;
         default: goto __pyx_L5_argtuple_error;
       }
     }
-    __pyx_v_high = ((PyArrayObject *)values[0]);
-    __pyx_v_low = ((PyArrayObject *)values[1]);
-    __pyx_v_close = ((PyArrayObject *)values[2]);
-    if (values[3]) {
-      __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[3]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 4058, __pyx_L3_error)
+    __pyx_v_real = ((PyArrayObject *)values[0]);
+    if (values[1]) {
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3714, __pyx_L3_error)
     } else {
-      __pyx_v_timeperiod = ((int)-2147483648);
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
     }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("NATR", 0, 3, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 4058, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("MAX", 0, 1, 2, __pyx_nargs); __PYX_ERR(4, 3712, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.NATR", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.MAX", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(2, 4058, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(2, 4058, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(2, 4058, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_262NATR(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_timeperiod);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 3714, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_240MAX(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_262NATR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_240MAX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -25803,51 +31018,40 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_262NATR(CYTHON_UNUSED PyObject *__pyx_
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  npy_intp __pyx_t_2;
-  npy_int __pyx_t_3;
-  __Pyx_RefNannySetupContext("NATR", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_high);
-  __Pyx_INCREF((PyObject *)__pyx_v_low);
-  __Pyx_INCREF((PyObject *)__pyx_v_close);
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4077, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4078, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
+  npy_int __pyx_t_2;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("MAX", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4079, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3733, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(2, 4080, __pyx_L1_error)
-  __pyx_v_length = __pyx_t_2;
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
-  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx3(__pyx_v_length, ((double *)__pyx_v_high->data), ((double *)__pyx_v_low->data), ((double *)__pyx_v_close->data)); if (unlikely(__pyx_t_3 == ((npy_int)-1))) __PYX_ERR(2, 4081, __pyx_L1_error)
-  __pyx_v_begidx = __pyx_t_3;
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3735, __pyx_L1_error)
+  __pyx_v_begidx = __pyx_t_2;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_NATR_Lookback(__pyx_v_timeperiod));
+  __pyx_v_lookback = (__pyx_v_begidx + TA_MAX_Lookback(__pyx_v_timeperiod));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4084, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3738, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_NATR(0, __pyx_v_endidx, (((double *)__pyx_v_high->data) + __pyx_v_begidx), (((double *)__pyx_v_low->data) + __pyx_v_begidx), (((double *)__pyx_v_close->data) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_v_outreal->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_MAX(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_NATR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4086, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_MAX, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3740, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outreal));
+  __Pyx_INCREF((PyObject *)__pyx_v_outreal);
   __pyx_r = ((PyObject *)__pyx_v_outreal);
   goto __pyx_L0;
 
@@ -25855,13 +31059,11 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_262NATR(CYTHON_UNUSED PyObject *__pyx_
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.NATR", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.MAX", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
-  __Pyx_XDECREF((PyObject *)__pyx_v_high);
-  __Pyx_XDECREF((PyObject *)__pyx_v_low);
-  __Pyx_XDECREF((PyObject *)__pyx_v_close);
+  __Pyx_XDECREF((PyObject *)__pyx_v_real);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -25869,75 +31071,119 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_262NATR(CYTHON_UNUSED PyObject *__pyx_
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_265OBV(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_264OBV[] = " OBV(real, volume)\n\n    On Balance Volume (Volume Indicators)\n\n    Inputs:\n        real: (any ndarray)\n        prices: ['volume']\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_265OBV = {"OBV", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_265OBV, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_264OBV};
-static PyObject *__pyx_pw_5talib_7_ta_lib_265OBV(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_243MAXINDEX(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_242MAXINDEX, "MAXINDEX(ndarray real, int timeperiod=-0x80000000)\n\nMAXINDEX(real[, timeperiod=?])\n\nIndex of highest value over a specified period (Math Operators)\n\nInputs:\n    real: (any ndarray)\nParameters:\n    timeperiod: 30\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_243MAXINDEX = {"MAXINDEX", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_243MAXINDEX, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_242MAXINDEX};
+static PyObject *__pyx_pw_5talib_7_ta_lib_243MAXINDEX(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_real = 0;
-  PyArrayObject *__pyx_v_volume = 0;
+  int __pyx_v_timeperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("OBV (wrapper)", 0);
+  __Pyx_RefNannySetupContext("MAXINDEX (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_volume,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);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 3743, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 3743, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3743, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "MAXINDEX", 0) < (0)) __PYX_ERR(4, 3743, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("MAXINDEX", 0, 1, 2, i); __PYX_ERR(4, 3743, __pyx_L3_error) }
+      }
+    } else {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 3743, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_volume)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("OBV", 1, 2, 2, 1); __PYX_ERR(2, 4091, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "OBV") < 0)) __PYX_ERR(2, 4091, __pyx_L3_error)
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3743, __pyx_L3_error)
+        break;
+        default: goto __pyx_L5_argtuple_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_real = ((PyArrayObject *)values[0]);
-    __pyx_v_volume = ((PyArrayObject *)values[1]);
+    if (values[1]) {
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3745, __pyx_L3_error)
+    } else {
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
+    }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("OBV", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 4091, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("MAXINDEX", 0, 1, 2, __pyx_nargs); __PYX_ERR(4, 3743, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.OBV", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.MAXINDEX", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(2, 4091, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_volume), __pyx_ptype_5numpy_ndarray, 0, "volume", 0))) __PYX_ERR(2, 4091, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_264OBV(__pyx_self, __pyx_v_real, __pyx_v_volume);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 3745, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_242MAXINDEX(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_264OBV(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, PyArrayObject *__pyx_v_volume) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_242MAXINDEX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -25945,62 +31191,69 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_264OBV(CYTHON_UNUSED PyObject *__pyx_s
   TA_RetCode __pyx_v_retCode;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  PyArrayObject *__pyx_v_outreal = 0;
+  PyArrayObject *__pyx_v_outinteger = 0;
+  int *__pyx_v_outinteger_data;
+  int __pyx_v_i;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  npy_intp __pyx_t_2;
-  npy_int __pyx_t_3;
-  __Pyx_RefNannySetupContext("OBV", 0);
+  npy_int __pyx_t_2;
+  npy_intp __pyx_t_3;
+  int __pyx_t_4;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("MAXINDEX", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_real);
-  __Pyx_INCREF((PyObject *)__pyx_v_volume);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4109, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3764, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_volume)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4110, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_volume, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_real, __pyx_v_volume); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(2, 4111, __pyx_L1_error)
-  __pyx_v_length = __pyx_t_2;
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
-  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx2(__pyx_v_length, ((double *)__pyx_v_real->data), ((double *)__pyx_v_volume->data)); if (unlikely(__pyx_t_3 == ((npy_int)-1))) __PYX_ERR(2, 4112, __pyx_L1_error)
-  __pyx_v_begidx = __pyx_t_3;
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3766, __pyx_L1_error)
+  __pyx_v_begidx = __pyx_t_2;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_OBV_Lookback());
+  __pyx_v_lookback = (__pyx_v_begidx + TA_MAXINDEX_Lookback(__pyx_v_timeperiod));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4115, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3769, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
+  __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_OBV(0, __pyx_v_endidx, (((double *)__pyx_v_real->data) + __pyx_v_begidx), (((double *)__pyx_v_volume->data) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_v_outreal->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_MAXINDEX(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_OBV, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4117, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_MAXINDEX, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3771, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
+  __pyx_v_outinteger_data = ((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger));
+
+  __pyx_t_3 = __pyx_v_length;
+  for (__pyx_v_i = __pyx_v_lookback; __pyx_v_i < __pyx_t_3; __pyx_v_i++) {
+
+    __pyx_t_4 = __pyx_v_i;
+    (__pyx_v_outinteger_data[__pyx_t_4]) = ((__pyx_v_outinteger_data[__pyx_t_4]) + __pyx_v_begidx);
+  }
+
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outreal));
-  __pyx_r = ((PyObject *)__pyx_v_outreal);
+  __Pyx_INCREF((PyObject *)__pyx_v_outinteger);
+  __pyx_r = ((PyObject *)__pyx_v_outinteger);
   goto __pyx_L0;
 
 
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.OBV", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.MAXINDEX", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
+  __Pyx_XDECREF((PyObject *)__pyx_v_outinteger);
   __Pyx_XDECREF((PyObject *)__pyx_v_real);
-  __Pyx_XDECREF((PyObject *)__pyx_v_volume);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -26008,105 +31261,111 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_264OBV(CYTHON_UNUSED PyObject *__pyx_s
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_267PLUS_DI(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_266PLUS_DI[] = " PLUS_DI(high, low, close[, timeperiod=?])\n\n    Plus Directional Indicator (Momentum Indicators)\n\n    Inputs:\n        prices: ['high', 'low', 'close']\n    Parameters:\n        timeperiod: 14\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_267PLUS_DI = {"PLUS_DI", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_267PLUS_DI, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_266PLUS_DI};
-static PyObject *__pyx_pw_5talib_7_ta_lib_267PLUS_DI(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_245MEDPRICE(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_244MEDPRICE, "MEDPRICE(ndarray high, ndarray low)\n\nMEDPRICE(high, low)\n\nMedian Price (Price Transform)\n\nInputs:\n    prices: ['high', 'low']\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_245MEDPRICE = {"MEDPRICE", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_245MEDPRICE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_244MEDPRICE};
+static PyObject *__pyx_pw_5talib_7_ta_lib_245MEDPRICE(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
-  PyArrayObject *__pyx_v_close = 0;
-  int __pyx_v_timeperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("PLUS_DI (wrapper)", 0);
+  __Pyx_RefNannySetupContext("MEDPRICE (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,&__pyx_n_s_timeperiod,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 3777, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 3777, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3777, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("PLUS_DI", 0, 3, 4, 1); __PYX_ERR(2, 4122, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("PLUS_DI", 0, 3, 4, 2); __PYX_ERR(2, 4122, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod);
-          if (value) { values[3] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "PLUS_DI") < 0)) __PYX_ERR(2, 4122, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "MEDPRICE", 0) < (0)) __PYX_ERR(4, 3777, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("MEDPRICE", 1, 2, 2, i); __PYX_ERR(4, 3777, __pyx_L3_error) }
       }
+    } else if (unlikely(__pyx_nargs != 2)) {
+      goto __pyx_L5_argtuple_error;
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-        break;
-        default: goto __pyx_L5_argtuple_error;
-      }
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3777, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 3777, __pyx_L3_error)
     }
     __pyx_v_high = ((PyArrayObject *)values[0]);
     __pyx_v_low = ((PyArrayObject *)values[1]);
-    __pyx_v_close = ((PyArrayObject *)values[2]);
-    if (values[3]) {
-      __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[3]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 4122, __pyx_L3_error)
-    } else {
-      __pyx_v_timeperiod = ((int)-2147483648);
-    }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("PLUS_DI", 0, 3, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 4122, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("MEDPRICE", 1, 2, 2, __pyx_nargs); __PYX_ERR(4, 3777, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.PLUS_DI", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.MEDPRICE", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(2, 4122, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(2, 4122, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(2, 4122, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_266PLUS_DI(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_timeperiod);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 3779, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 3779, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_244MEDPRICE(__pyx_self, __pyx_v_high, __pyx_v_low);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_266PLUS_DI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_244MEDPRICE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -26120,49 +31379,46 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_266PLUS_DI(CYTHON_UNUSED PyObject *__p
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
   npy_int __pyx_t_3;
-  __Pyx_RefNannySetupContext("PLUS_DI", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("MEDPRICE", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
-  __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4141, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3796, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4142, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3797, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4143, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(2, 4144, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_high, __pyx_v_low); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 3798, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
-  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx3(__pyx_v_length, ((double *)__pyx_v_high->data), ((double *)__pyx_v_low->data), ((double *)__pyx_v_close->data)); if (unlikely(__pyx_t_3 == ((npy_int)-1))) __PYX_ERR(2, 4145, __pyx_L1_error)
+  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx2(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3799, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_3;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_PLUS_DI_Lookback(__pyx_v_timeperiod));
+  __pyx_v_lookback = (__pyx_v_begidx + TA_MEDPRICE_Lookback());
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4148, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3802, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_PLUS_DI(0, __pyx_v_endidx, (((double *)__pyx_v_high->data) + __pyx_v_begidx), (((double *)__pyx_v_low->data) + __pyx_v_begidx), (((double *)__pyx_v_close->data) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_v_outreal->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_MEDPRICE(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_PLUS_DI, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4150, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_MEDPRICE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3804, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outreal));
+  __Pyx_INCREF((PyObject *)__pyx_v_outreal);
   __pyx_r = ((PyObject *)__pyx_v_outreal);
   goto __pyx_L0;
 
@@ -26170,13 +31426,12 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_266PLUS_DI(CYTHON_UNUSED PyObject *__p
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.PLUS_DI", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.MEDPRICE", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
   __Pyx_XDECREF((PyObject *)__pyx_v_high);
   __Pyx_XDECREF((PyObject *)__pyx_v_low);
-  __Pyx_XDECREF((PyObject *)__pyx_v_close);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -26184,93 +31439,146 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_266PLUS_DI(CYTHON_UNUSED PyObject *__p
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_269PLUS_DM(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_268PLUS_DM[] = " PLUS_DM(high, low[, timeperiod=?])\n\n    Plus Directional Movement (Momentum Indicators)\n\n    Inputs:\n        prices: ['high', 'low']\n    Parameters:\n        timeperiod: 14\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_269PLUS_DM = {"PLUS_DM", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_269PLUS_DM, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_268PLUS_DM};
-static PyObject *__pyx_pw_5talib_7_ta_lib_269PLUS_DM(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_247MFI(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_246MFI, "MFI(ndarray high, ndarray low, ndarray close, ndarray volume, int timeperiod=-0x80000000)\n\nMFI(high, low, close, volume[, timeperiod=?])\n\nMoney Flow Index (Momentum Indicators)\n\nInputs:\n    prices: ['high', 'low', 'close', 'volume']\nParameters:\n    timeperiod: 14\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_247MFI = {"MFI", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_247MFI, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_246MFI};
+static PyObject *__pyx_pw_5talib_7_ta_lib_247MFI(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
+  PyArrayObject *__pyx_v_close = 0;
+  PyArrayObject *__pyx_v_volume = 0;
   int __pyx_v_timeperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[5] = {0,0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("PLUS_DM (wrapper)", 0);
+  __Pyx_RefNannySetupContext("MFI (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_timeperiod,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);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,&__pyx_mstate_global->__pyx_n_u_volume,&__pyx_mstate_global->__pyx_n_u_timeperiod,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 3807, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  5:
+        values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(4, 3807, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 3807, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 3807, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  0: break;
-        default: goto __pyx_L5_argtuple_error;
-      }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 3807, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("PLUS_DM", 0, 2, 3, 1); __PYX_ERR(2, 4155, __pyx_L3_error)
-        }
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3807, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod);
-          if (value) { values[2] = value; kw_args--; }
-        }
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
       }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "PLUS_DM") < 0)) __PYX_ERR(2, 4155, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "MFI", 0) < (0)) __PYX_ERR(4, 3807, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("MFI", 0, 4, 5, i); __PYX_ERR(4, 3807, __pyx_L3_error) }
       }
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+      switch (__pyx_nargs) {
+        case  5:
+        values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(4, 3807, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 3807, __pyx_L3_error)
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 3807, __pyx_L3_error)
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 3807, __pyx_L3_error)
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3807, __pyx_L3_error)
         break;
         default: goto __pyx_L5_argtuple_error;
       }
     }
     __pyx_v_high = ((PyArrayObject *)values[0]);
     __pyx_v_low = ((PyArrayObject *)values[1]);
-    if (values[2]) {
-      __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 4155, __pyx_L3_error)
+    __pyx_v_close = ((PyArrayObject *)values[2]);
+    __pyx_v_volume = ((PyArrayObject *)values[3]);
+    if (values[4]) {
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[4]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3809, __pyx_L3_error)
     } else {
-      __pyx_v_timeperiod = ((int)-2147483648);
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
     }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("PLUS_DM", 0, 2, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 4155, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("MFI", 0, 4, 5, __pyx_nargs); __PYX_ERR(4, 3807, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.PLUS_DM", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.MFI", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(2, 4155, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(2, 4155, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_268PLUS_DM(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_timeperiod);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 3809, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 3809, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 3809, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_volume), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "volume", 0))) __PYX_ERR(4, 3809, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_246MFI(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_volume, __pyx_v_timeperiod);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_268PLUS_DM(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, int __pyx_v_timeperiod) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_246MFI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, PyArrayObject *__pyx_v_volume, int __pyx_v_timeperiod) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -26284,43 +31592,58 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_268PLUS_DM(CYTHON_UNUSED PyObject *__p
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
   npy_int __pyx_t_3;
-  __Pyx_RefNannySetupContext("PLUS_DM", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("MFI", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
+  __Pyx_INCREF((PyObject *)__pyx_v_close);
+  __Pyx_INCREF((PyObject *)__pyx_v_volume);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4174, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3828, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4175, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3829, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_high, __pyx_v_low); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(2, 4176, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3830, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
+
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_volume)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3831, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_volume, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
+
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_volume); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 3832, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
-  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx2(__pyx_v_length, ((double *)__pyx_v_high->data), ((double *)__pyx_v_low->data)); if (unlikely(__pyx_t_3 == ((npy_int)-1))) __PYX_ERR(2, 4177, __pyx_L1_error)
+  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_volume))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3833, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_3;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_PLUS_DM_Lookback(__pyx_v_timeperiod));
+  __pyx_v_lookback = (__pyx_v_begidx + TA_MFI_Lookback(__pyx_v_timeperiod));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4180, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3836, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_PLUS_DM(0, __pyx_v_endidx, (((double *)__pyx_v_high->data) + __pyx_v_begidx), (((double *)__pyx_v_low->data) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_v_outreal->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_MFI(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_volume)) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_PLUS_DM, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4182, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_MFI, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3838, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outreal));
+  __Pyx_INCREF((PyObject *)__pyx_v_outreal);
   __pyx_r = ((PyObject *)__pyx_v_outreal);
   goto __pyx_L0;
 
@@ -26328,12 +31651,14 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_268PLUS_DM(CYTHON_UNUSED PyObject *__p
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.PLUS_DM", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.MFI", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
   __Pyx_XDECREF((PyObject *)__pyx_v_high);
   __Pyx_XDECREF((PyObject *)__pyx_v_low);
+  __Pyx_XDECREF((PyObject *)__pyx_v_close);
+  __Pyx_XDECREF((PyObject *)__pyx_v_volume);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -26341,113 +31666,119 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_268PLUS_DM(CYTHON_UNUSED PyObject *__p
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_271PPO(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_270PPO[] = " PPO(real[, fastperiod=?, slowperiod=?, matype=?])\n\n    Percentage Price Oscillator (Momentum Indicators)\n\n    Inputs:\n        real: (any ndarray)\n    Parameters:\n        fastperiod: 12\n        slowperiod: 26\n        matype: 0 (Simple Moving Average)\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_271PPO = {"PPO", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_271PPO, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_270PPO};
-static PyObject *__pyx_pw_5talib_7_ta_lib_271PPO(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_249MIDPOINT(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_248MIDPOINT, "MIDPOINT(ndarray real, int timeperiod=-0x80000000)\n\nMIDPOINT(real[, timeperiod=?])\n\nMidPoint over period (Overlap Studies)\n\nInputs:\n    real: (any ndarray)\nParameters:\n    timeperiod: 14\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_249MIDPOINT = {"MIDPOINT", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_249MIDPOINT, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_248MIDPOINT};
+static PyObject *__pyx_pw_5talib_7_ta_lib_249MIDPOINT(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_real = 0;
-  int __pyx_v_fastperiod;
-  int __pyx_v_slowperiod;
-  int __pyx_v_matype;
+  int __pyx_v_timeperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("PPO (wrapper)", 0);
+  __Pyx_RefNannySetupContext("MIDPOINT (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_fastperiod,&__pyx_n_s_slowperiod,&__pyx_n_s_matype,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 3841, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 3841, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3841, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_fastperiod);
-          if (value) { values[1] = value; kw_args--; }
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_slowperiod);
-          if (value) { values[2] = value; kw_args--; }
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_matype);
-          if (value) { values[3] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "PPO") < 0)) __PYX_ERR(2, 4187, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "MIDPOINT", 0) < (0)) __PYX_ERR(4, 3841, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("MIDPOINT", 0, 1, 2, i); __PYX_ERR(4, 3841, __pyx_L3_error) }
       }
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 3841, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3841, __pyx_L3_error)
         break;
         default: goto __pyx_L5_argtuple_error;
       }
     }
     __pyx_v_real = ((PyArrayObject *)values[0]);
     if (values[1]) {
-      __pyx_v_fastperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_fastperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 4187, __pyx_L3_error)
-    } else {
-      __pyx_v_fastperiod = ((int)-2147483648);
-    }
-    if (values[2]) {
-      __pyx_v_slowperiod = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_slowperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 4187, __pyx_L3_error)
-    } else {
-      __pyx_v_slowperiod = ((int)-2147483648);
-    }
-    if (values[3]) {
-      __pyx_v_matype = __Pyx_PyInt_As_int(values[3]); if (unlikely((__pyx_v_matype == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 4187, __pyx_L3_error)
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3843, __pyx_L3_error)
     } else {
-      __pyx_v_matype = ((int)0);
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
     }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("PPO", 0, 1, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 4187, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("MIDPOINT", 0, 1, 2, __pyx_nargs); __PYX_ERR(4, 3841, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.PPO", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.MIDPOINT", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(2, 4187, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_270PPO(__pyx_self, __pyx_v_real, __pyx_v_fastperiod, __pyx_v_slowperiod, __pyx_v_matype);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 3843, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_248MIDPOINT(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_270PPO(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_fastperiod, int __pyx_v_slowperiod, int __pyx_v_matype) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_248MIDPOINT(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -26460,36 +31791,39 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_270PPO(CYTHON_UNUSED PyObject *__pyx_s
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_int __pyx_t_2;
-  __Pyx_RefNannySetupContext("PPO", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("MIDPOINT", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4208, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3862, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_v_real->data)); if (unlikely(__pyx_t_2 == ((npy_int)-1))) __PYX_ERR(2, 4210, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3864, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_2;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_PPO_Lookback(__pyx_v_fastperiod, __pyx_v_slowperiod, __pyx_v_matype));
+  __pyx_v_lookback = (__pyx_v_begidx + TA_MIDPOINT_Lookback(__pyx_v_timeperiod));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4213, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3867, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_PPO(0, __pyx_v_endidx, (((double *)__pyx_v_real->data) + __pyx_v_begidx), __pyx_v_fastperiod, __pyx_v_slowperiod, __pyx_v_matype, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_v_outreal->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_MIDPOINT(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_PPO, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4215, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_MIDPOINT, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3869, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outreal));
+  __Pyx_INCREF((PyObject *)__pyx_v_outreal);
   __pyx_r = ((PyObject *)__pyx_v_outreal);
   goto __pyx_L0;
 
@@ -26497,7 +31831,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_270PPO(CYTHON_UNUSED PyObject *__pyx_s
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.PPO", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.MIDPOINT", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
@@ -26509,81 +31843,128 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_270PPO(CYTHON_UNUSED PyObject *__pyx_s
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_273ROC(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_272ROC[] = " ROC(real[, timeperiod=?])\n\n    Rate of change : ((real/prevPrice)-1)*100 (Momentum Indicators)\n\n    Inputs:\n        real: (any ndarray)\n    Parameters:\n        timeperiod: 10\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_273ROC = {"ROC", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_273ROC, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_272ROC};
-static PyObject *__pyx_pw_5talib_7_ta_lib_273ROC(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_real = 0;
+static PyObject *__pyx_pw_5talib_7_ta_lib_251MIDPRICE(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_250MIDPRICE, "MIDPRICE(ndarray high, ndarray low, int timeperiod=-0x80000000)\n\nMIDPRICE(high, low[, timeperiod=?])\n\nMidpoint Price over period (Overlap Studies)\n\nInputs:\n    prices: ['high', 'low']\nParameters:\n    timeperiod: 14\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_251MIDPRICE = {"MIDPRICE", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_251MIDPRICE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_250MIDPRICE};
+static PyObject *__pyx_pw_5talib_7_ta_lib_251MIDPRICE(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_high = 0;
+  PyArrayObject *__pyx_v_low = 0;
   int __pyx_v_timeperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[3] = {0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("ROC (wrapper)", 0);
+  __Pyx_RefNannySetupContext("MIDPRICE (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,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);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_timeperiod,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 3872, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 3872, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 3872, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3872, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod);
-          if (value) { values[1] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "ROC") < 0)) __PYX_ERR(2, 4220, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "MIDPRICE", 0) < (0)) __PYX_ERR(4, 3872, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("MIDPRICE", 0, 2, 3, i); __PYX_ERR(4, 3872, __pyx_L3_error) }
       }
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      switch (__pyx_nargs) {
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 3872, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 3872, __pyx_L3_error)
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3872, __pyx_L3_error)
         break;
         default: goto __pyx_L5_argtuple_error;
       }
     }
-    __pyx_v_real = ((PyArrayObject *)values[0]);
-    if (values[1]) {
-      __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 4220, __pyx_L3_error)
+    __pyx_v_high = ((PyArrayObject *)values[0]);
+    __pyx_v_low = ((PyArrayObject *)values[1]);
+    if (values[2]) {
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[2]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3874, __pyx_L3_error)
     } else {
-      __pyx_v_timeperiod = ((int)-2147483648);
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
     }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("ROC", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 4220, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("MIDPRICE", 0, 2, 3, __pyx_nargs); __PYX_ERR(4, 3872, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.ROC", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.MIDPRICE", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(2, 4220, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_272ROC(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 3874, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 3874, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_250MIDPRICE(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_timeperiod);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_272ROC(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_250MIDPRICE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, int __pyx_v_timeperiod) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -26595,37 +31976,48 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_272ROC(CYTHON_UNUSED PyObject *__pyx_s
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  npy_int __pyx_t_2;
-  __Pyx_RefNannySetupContext("ROC", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_real);
+  npy_intp __pyx_t_2;
+  npy_int __pyx_t_3;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("MIDPRICE", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_high);
+  __Pyx_INCREF((PyObject *)__pyx_v_low);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4239, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3893, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3894, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_v_real->data)); if (unlikely(__pyx_t_2 == ((npy_int)-1))) __PYX_ERR(2, 4241, __pyx_L1_error)
-  __pyx_v_begidx = __pyx_t_2;
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_high, __pyx_v_low); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 3895, __pyx_L1_error)
+  __pyx_v_length = __pyx_t_2;
+
+  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx2(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3896, __pyx_L1_error)
+  __pyx_v_begidx = __pyx_t_3;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_ROC_Lookback(__pyx_v_timeperiod));
+  __pyx_v_lookback = (__pyx_v_begidx + TA_MIDPRICE_Lookback(__pyx_v_timeperiod));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4244, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3899, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_ROC(0, __pyx_v_endidx, (((double *)__pyx_v_real->data) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_v_outreal->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_MIDPRICE(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_ROC, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4246, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_MIDPRICE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3901, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outreal));
+  __Pyx_INCREF((PyObject *)__pyx_v_outreal);
   __pyx_r = ((PyObject *)__pyx_v_outreal);
   goto __pyx_L0;
 
@@ -26633,11 +32025,12 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_272ROC(CYTHON_UNUSED PyObject *__pyx_s
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.ROC", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.MIDPRICE", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
-  __Pyx_XDECREF((PyObject *)__pyx_v_real);
+  __Pyx_XDECREF((PyObject *)__pyx_v_high);
+  __Pyx_XDECREF((PyObject *)__pyx_v_low);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -26645,81 +32038,119 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_272ROC(CYTHON_UNUSED PyObject *__pyx_s
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_275ROCP(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_274ROCP[] = " ROCP(real[, timeperiod=?])\n\n    Rate of change Percentage: (real-prevPrice)/prevPrice (Momentum Indicators)\n\n    Inputs:\n        real: (any ndarray)\n    Parameters:\n        timeperiod: 10\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_275ROCP = {"ROCP", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_275ROCP, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_274ROCP};
-static PyObject *__pyx_pw_5talib_7_ta_lib_275ROCP(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_253MIN(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_252MIN, "MIN(ndarray real, int timeperiod=-0x80000000)\n\nMIN(real[, timeperiod=?])\n\nLowest value over a specified period (Math Operators)\n\nInputs:\n    real: (any ndarray)\nParameters:\n    timeperiod: 30\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_253MIN = {"MIN", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_253MIN, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_252MIN};
+static PyObject *__pyx_pw_5talib_7_ta_lib_253MIN(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_real = 0;
   int __pyx_v_timeperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("ROCP (wrapper)", 0);
+  __Pyx_RefNannySetupContext("MIN (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,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);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 3904, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 3904, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3904, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod);
-          if (value) { values[1] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "ROCP") < 0)) __PYX_ERR(2, 4251, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "MIN", 0) < (0)) __PYX_ERR(4, 3904, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("MIN", 0, 1, 2, i); __PYX_ERR(4, 3904, __pyx_L3_error) }
       }
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 3904, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3904, __pyx_L3_error)
         break;
         default: goto __pyx_L5_argtuple_error;
       }
     }
     __pyx_v_real = ((PyArrayObject *)values[0]);
     if (values[1]) {
-      __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 4251, __pyx_L3_error)
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3906, __pyx_L3_error)
     } else {
-      __pyx_v_timeperiod = ((int)-2147483648);
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
     }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("ROCP", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 4251, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("MIN", 0, 1, 2, __pyx_nargs); __PYX_ERR(4, 3904, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.ROCP", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.MIN", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(2, 4251, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_274ROCP(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 3906, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_252MIN(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_274ROCP(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_252MIN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -26732,36 +32163,39 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_274ROCP(CYTHON_UNUSED PyObject *__pyx_
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_int __pyx_t_2;
-  __Pyx_RefNannySetupContext("ROCP", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("MIN", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4270, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3925, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_v_real->data)); if (unlikely(__pyx_t_2 == ((npy_int)-1))) __PYX_ERR(2, 4272, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3927, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_2;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_ROCP_Lookback(__pyx_v_timeperiod));
+  __pyx_v_lookback = (__pyx_v_begidx + TA_MIN_Lookback(__pyx_v_timeperiod));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4275, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3930, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_ROCP(0, __pyx_v_endidx, (((double *)__pyx_v_real->data) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_v_outreal->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_MIN(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_ROCP, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4277, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_MIN, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3932, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outreal));
+  __Pyx_INCREF((PyObject *)__pyx_v_outreal);
   __pyx_r = ((PyObject *)__pyx_v_outreal);
   goto __pyx_L0;
 
@@ -26769,7 +32203,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_274ROCP(CYTHON_UNUSED PyObject *__pyx_
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.ROCP", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.MIN", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
@@ -26781,81 +32215,119 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_274ROCP(CYTHON_UNUSED PyObject *__pyx_
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_277ROCR(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_276ROCR[] = " ROCR(real[, timeperiod=?])\n\n    Rate of change ratio: (real/prevPrice) (Momentum Indicators)\n\n    Inputs:\n        real: (any ndarray)\n    Parameters:\n        timeperiod: 10\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_277ROCR = {"ROCR", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_277ROCR, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_276ROCR};
-static PyObject *__pyx_pw_5talib_7_ta_lib_277ROCR(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_255MININDEX(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_254MININDEX, "MININDEX(ndarray real, int timeperiod=-0x80000000)\n\nMININDEX(real[, timeperiod=?])\n\nIndex of lowest value over a specified period (Math Operators)\n\nInputs:\n    real: (any ndarray)\nParameters:\n    timeperiod: 30\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_255MININDEX = {"MININDEX", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_255MININDEX, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_254MININDEX};
+static PyObject *__pyx_pw_5talib_7_ta_lib_255MININDEX(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_real = 0;
   int __pyx_v_timeperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("ROCR (wrapper)", 0);
+  __Pyx_RefNannySetupContext("MININDEX (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,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);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 3935, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 3935, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3935, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod);
-          if (value) { values[1] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "ROCR") < 0)) __PYX_ERR(2, 4282, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "MININDEX", 0) < (0)) __PYX_ERR(4, 3935, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("MININDEX", 0, 1, 2, i); __PYX_ERR(4, 3935, __pyx_L3_error) }
       }
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 3935, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3935, __pyx_L3_error)
         break;
         default: goto __pyx_L5_argtuple_error;
       }
     }
     __pyx_v_real = ((PyArrayObject *)values[0]);
     if (values[1]) {
-      __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 4282, __pyx_L3_error)
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3937, __pyx_L3_error)
     } else {
-      __pyx_v_timeperiod = ((int)-2147483648);
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
     }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("ROCR", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 4282, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("MININDEX", 0, 1, 2, __pyx_nargs); __PYX_ERR(4, 3935, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.ROCR", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.MININDEX", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(2, 4282, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_276ROCR(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 3937, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_254MININDEX(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_276ROCR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_254MININDEX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -26863,52 +32335,68 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_276ROCR(CYTHON_UNUSED PyObject *__pyx_
   TA_RetCode __pyx_v_retCode;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  PyArrayObject *__pyx_v_outreal = 0;
+  PyArrayObject *__pyx_v_outinteger = 0;
+  int *__pyx_v_outinteger_data;
+  int __pyx_v_i;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_int __pyx_t_2;
-  __Pyx_RefNannySetupContext("ROCR", 0);
+  npy_intp __pyx_t_3;
+  int __pyx_t_4;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("MININDEX", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4301, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3956, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_v_real->data)); if (unlikely(__pyx_t_2 == ((npy_int)-1))) __PYX_ERR(2, 4303, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3958, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_2;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_ROCR_Lookback(__pyx_v_timeperiod));
+  __pyx_v_lookback = (__pyx_v_begidx + TA_MININDEX_Lookback(__pyx_v_timeperiod));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4306, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3961, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
+  __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_ROCR(0, __pyx_v_endidx, (((double *)__pyx_v_real->data) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_v_outreal->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_MININDEX(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_ROCR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4308, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_MININDEX, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3963, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
+  __pyx_v_outinteger_data = ((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger));
+
+  __pyx_t_3 = __pyx_v_length;
+  for (__pyx_v_i = __pyx_v_lookback; __pyx_v_i < __pyx_t_3; __pyx_v_i++) {
+
+    __pyx_t_4 = __pyx_v_i;
+    (__pyx_v_outinteger_data[__pyx_t_4]) = ((__pyx_v_outinteger_data[__pyx_t_4]) + __pyx_v_begidx);
+  }
+
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outreal));
-  __pyx_r = ((PyObject *)__pyx_v_outreal);
+  __Pyx_INCREF((PyObject *)__pyx_v_outinteger);
+  __pyx_r = ((PyObject *)__pyx_v_outinteger);
   goto __pyx_L0;
 
 
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.ROCR", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.MININDEX", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
+  __Pyx_XDECREF((PyObject *)__pyx_v_outinteger);
   __Pyx_XDECREF((PyObject *)__pyx_v_real);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
@@ -26917,81 +32405,119 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_276ROCR(CYTHON_UNUSED PyObject *__pyx_
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_279ROCR100(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_278ROCR100[] = " ROCR100(real[, timeperiod=?])\n\n    Rate of change ratio 100 scale: (real/prevPrice)*100 (Momentum Indicators)\n\n    Inputs:\n        real: (any ndarray)\n    Parameters:\n        timeperiod: 10\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_279ROCR100 = {"ROCR100", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_279ROCR100, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_278ROCR100};
-static PyObject *__pyx_pw_5talib_7_ta_lib_279ROCR100(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_257MINMAX(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_256MINMAX, "MINMAX(ndarray real, int timeperiod=-0x80000000)\n\nMINMAX(real[, timeperiod=?])\n\nLowest and highest values over a specified period (Math Operators)\n\nInputs:\n    real: (any ndarray)\nParameters:\n    timeperiod: 30\nOutputs:\n    min\n    max");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_257MINMAX = {"MINMAX", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_257MINMAX, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_256MINMAX};
+static PyObject *__pyx_pw_5talib_7_ta_lib_257MINMAX(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_real = 0;
   int __pyx_v_timeperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("ROCR100 (wrapper)", 0);
+  __Pyx_RefNannySetupContext("MINMAX (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,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);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 3969, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 3969, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3969, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod);
-          if (value) { values[1] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "ROCR100") < 0)) __PYX_ERR(2, 4313, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "MINMAX", 0) < (0)) __PYX_ERR(4, 3969, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("MINMAX", 0, 1, 2, i); __PYX_ERR(4, 3969, __pyx_L3_error) }
       }
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 3969, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 3969, __pyx_L3_error)
         break;
         default: goto __pyx_L5_argtuple_error;
       }
     }
     __pyx_v_real = ((PyArrayObject *)values[0]);
     if (values[1]) {
-      __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 4313, __pyx_L3_error)
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3971, __pyx_L3_error)
     } else {
-      __pyx_v_timeperiod = ((int)-2147483648);
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
     }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("ROCR100", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 4313, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("MINMAX", 0, 1, 2, __pyx_nargs); __PYX_ERR(4, 3969, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.ROCR100", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.MINMAX", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(2, 4313, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_278ROCR100(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 3971, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_256MINMAX(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_278ROCR100(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_256MINMAX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -26999,52 +32525,70 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_278ROCR100(CYTHON_UNUSED PyObject *__p
   TA_RetCode __pyx_v_retCode;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  PyArrayObject *__pyx_v_outreal = 0;
+  PyArrayObject *__pyx_v_outmin = 0;
+  PyArrayObject *__pyx_v_outmax = 0;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_int __pyx_t_2;
-  __Pyx_RefNannySetupContext("ROCR100", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("MINMAX", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4332, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3992, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_v_real->data)); if (unlikely(__pyx_t_2 == ((npy_int)-1))) __PYX_ERR(2, 4334, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3994, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_2;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_ROCR100_Lookback(__pyx_v_timeperiod));
+  __pyx_v_lookback = (__pyx_v_begidx + TA_MINMAX_Lookback(__pyx_v_timeperiod));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4337, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3997, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
+  __pyx_v_outmin = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_ROCR100(0, __pyx_v_endidx, (((double *)__pyx_v_real->data) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_v_outreal->data) + __pyx_v_lookback));
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3998, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_outmax = ((PyArrayObject *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  __pyx_v_retCode = TA_MINMAX(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outmin)) + __pyx_v_lookback), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outmax)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_ROCR100, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4339, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_MINMAX, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4000, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outreal));
-  __pyx_r = ((PyObject *)__pyx_v_outreal);
+  __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4001, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_INCREF((PyObject *)__pyx_v_outmin);
+  __Pyx_GIVEREF((PyObject *)__pyx_v_outmin);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_outmin)) != (0)) __PYX_ERR(4, 4001, __pyx_L1_error);
+  __Pyx_INCREF((PyObject *)__pyx_v_outmax);
+  __Pyx_GIVEREF((PyObject *)__pyx_v_outmax);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, ((PyObject *)__pyx_v_outmax)) != (0)) __PYX_ERR(4, 4001, __pyx_L1_error);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
   goto __pyx_L0;
 
 
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.ROCR100", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.MINMAX", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
+  __Pyx_XDECREF((PyObject *)__pyx_v_outmin);
+  __Pyx_XDECREF((PyObject *)__pyx_v_outmax);
   __Pyx_XDECREF((PyObject *)__pyx_v_real);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
@@ -27053,81 +32597,119 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_278ROCR100(CYTHON_UNUSED PyObject *__p
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_281RSI(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_280RSI[] = " RSI(real[, timeperiod=?])\n\n    Relative Strength Index (Momentum Indicators)\n\n    Inputs:\n        real: (any ndarray)\n    Parameters:\n        timeperiod: 14\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_281RSI = {"RSI", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_281RSI, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_280RSI};
-static PyObject *__pyx_pw_5talib_7_ta_lib_281RSI(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_259MINMAXINDEX(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_258MINMAXINDEX, "MINMAXINDEX(ndarray real, int timeperiod=-0x80000000)\n\nMINMAXINDEX(real[, timeperiod=?])\n\nIndexes of lowest and highest values over a specified period (Math Operators)\n\nInputs:\n    real: (any ndarray)\nParameters:\n    timeperiod: 30\nOutputs:\n    minidx\n    maxidx");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_259MINMAXINDEX = {"MINMAXINDEX", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_259MINMAXINDEX, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_258MINMAXINDEX};
+static PyObject *__pyx_pw_5talib_7_ta_lib_259MINMAXINDEX(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_real = 0;
   int __pyx_v_timeperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("RSI (wrapper)", 0);
+  __Pyx_RefNannySetupContext("MINMAXINDEX (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,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);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 4003, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 4003, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4003, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod);
-          if (value) { values[1] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "RSI") < 0)) __PYX_ERR(2, 4344, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "MINMAXINDEX", 0) < (0)) __PYX_ERR(4, 4003, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("MINMAXINDEX", 0, 1, 2, i); __PYX_ERR(4, 4003, __pyx_L3_error) }
       }
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 4003, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4003, __pyx_L3_error)
         break;
         default: goto __pyx_L5_argtuple_error;
       }
     }
     __pyx_v_real = ((PyArrayObject *)values[0]);
     if (values[1]) {
-      __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 4344, __pyx_L3_error)
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4005, __pyx_L3_error)
     } else {
-      __pyx_v_timeperiod = ((int)-2147483648);
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
     }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("RSI", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 4344, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("MINMAXINDEX", 0, 1, 2, __pyx_nargs); __PYX_ERR(4, 4003, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.RSI", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.MINMAXINDEX", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(2, 4344, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_280RSI(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 4005, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_258MINMAXINDEX(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_280RSI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_258MINMAXINDEX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -27135,52 +32717,93 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_280RSI(CYTHON_UNUSED PyObject *__pyx_s
   TA_RetCode __pyx_v_retCode;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  PyArrayObject *__pyx_v_outreal = 0;
+  PyArrayObject *__pyx_v_outminidx = 0;
+  PyArrayObject *__pyx_v_outmaxidx = 0;
+  int *__pyx_v_outminidx_data;
+  int __pyx_v_i;
+  int *__pyx_v_outmaxidx_data;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_int __pyx_t_2;
-  __Pyx_RefNannySetupContext("RSI", 0);
+  npy_intp __pyx_t_3;
+  int __pyx_t_4;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("MINMAXINDEX", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4363, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4026, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_v_real->data)); if (unlikely(__pyx_t_2 == ((npy_int)-1))) __PYX_ERR(2, 4365, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4028, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_2;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_RSI_Lookback(__pyx_v_timeperiod));
+  __pyx_v_lookback = (__pyx_v_begidx + TA_MINMAXINDEX_Lookback(__pyx_v_timeperiod));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4368, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4031, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
+  __pyx_v_outminidx = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_RSI(0, __pyx_v_endidx, (((double *)__pyx_v_real->data) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_v_outreal->data) + __pyx_v_lookback));
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_int_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4032, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_outmaxidx = ((PyArrayObject *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  __pyx_v_retCode = TA_MINMAXINDEX(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outminidx)) + __pyx_v_lookback), (((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outmaxidx)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_RSI, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4370, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_MINMAXINDEX, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4034, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
+  __pyx_v_outminidx_data = ((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outminidx));
+
+  __pyx_t_3 = __pyx_v_length;
+  for (__pyx_v_i = __pyx_v_lookback; __pyx_v_i < __pyx_t_3; __pyx_v_i++) {
+
+    __pyx_t_4 = __pyx_v_i;
+    (__pyx_v_outminidx_data[__pyx_t_4]) = ((__pyx_v_outminidx_data[__pyx_t_4]) + __pyx_v_begidx);
+  }
+
+  __pyx_v_outmaxidx_data = ((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outmaxidx));
+
+  __pyx_t_3 = __pyx_v_length;
+  for (__pyx_v_i = __pyx_v_lookback; __pyx_v_i < __pyx_t_3; __pyx_v_i++) {
+
+    __pyx_t_4 = __pyx_v_i;
+    (__pyx_v_outmaxidx_data[__pyx_t_4]) = ((__pyx_v_outmaxidx_data[__pyx_t_4]) + __pyx_v_begidx);
+  }
+
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outreal));
-  __pyx_r = ((PyObject *)__pyx_v_outreal);
+  __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4041, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_INCREF((PyObject *)__pyx_v_outminidx);
+  __Pyx_GIVEREF((PyObject *)__pyx_v_outminidx);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_outminidx)) != (0)) __PYX_ERR(4, 4041, __pyx_L1_error);
+  __Pyx_INCREF((PyObject *)__pyx_v_outmaxidx);
+  __Pyx_GIVEREF((PyObject *)__pyx_v_outmaxidx);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, ((PyObject *)__pyx_v_outmaxidx)) != (0)) __PYX_ERR(4, 4041, __pyx_L1_error);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
   goto __pyx_L0;
 
 
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.RSI", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.MINMAXINDEX", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
+  __Pyx_XDECREF((PyObject *)__pyx_v_outminidx);
+  __Pyx_XDECREF((PyObject *)__pyx_v_outmaxidx);
   __Pyx_XDECREF((PyObject *)__pyx_v_real);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
@@ -27189,109 +32812,137 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_280RSI(CYTHON_UNUSED PyObject *__pyx_s
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_283SAR(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_282SAR[] = " SAR(high, low[, acceleration=?, maximum=?])\n\n    Parabolic SAR (Overlap Studies)\n\n    Inputs:\n        prices: ['high', 'low']\n    Parameters:\n        acceleration: 0.02\n        maximum: 0.2\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_283SAR = {"SAR", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_283SAR, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_282SAR};
-static PyObject *__pyx_pw_5talib_7_ta_lib_283SAR(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_261MINUS_DI(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_260MINUS_DI, "MINUS_DI(ndarray high, ndarray low, ndarray close, int timeperiod=-0x80000000)\n\nMINUS_DI(high, low, close[, timeperiod=?])\n\nMinus Directional Indicator (Momentum Indicators)\n\nInputs:\n    prices: ['high', 'low', 'close']\nParameters:\n    timeperiod: 14\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_261MINUS_DI = {"MINUS_DI", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_261MINUS_DI, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_260MINUS_DI};
+static PyObject *__pyx_pw_5talib_7_ta_lib_261MINUS_DI(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
-  double __pyx_v_acceleration;
-  double __pyx_v_maximum;
+  PyArrayObject *__pyx_v_close = 0;
+  int __pyx_v_timeperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("SAR (wrapper)", 0);
+  __Pyx_RefNannySetupContext("MINUS_DI (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_acceleration,&__pyx_n_s_maximum,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,&__pyx_mstate_global->__pyx_n_u_timeperiod,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 4043, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 4043, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 4043, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 4043, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4043, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("SAR", 0, 2, 4, 1); __PYX_ERR(2, 4375, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_acceleration);
-          if (value) { values[2] = value; kw_args--; }
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_maximum);
-          if (value) { values[3] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "SAR") < 0)) __PYX_ERR(2, 4375, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "MINUS_DI", 0) < (0)) __PYX_ERR(4, 4043, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 3; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("MINUS_DI", 0, 3, 4, i); __PYX_ERR(4, 4043, __pyx_L3_error) }
       }
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 4043, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 4043, __pyx_L3_error)
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 4043, __pyx_L3_error)
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4043, __pyx_L3_error)
         break;
         default: goto __pyx_L5_argtuple_error;
       }
     }
     __pyx_v_high = ((PyArrayObject *)values[0]);
     __pyx_v_low = ((PyArrayObject *)values[1]);
-    if (values[2]) {
-      __pyx_v_acceleration = __pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_acceleration == (double)-1) && PyErr_Occurred())) __PYX_ERR(2, 4375, __pyx_L3_error)
-    } else {
-      __pyx_v_acceleration = ((double)0.02);
-    }
+    __pyx_v_close = ((PyArrayObject *)values[2]);
     if (values[3]) {
-      __pyx_v_maximum = __pyx_PyFloat_AsDouble(values[3]); if (unlikely((__pyx_v_maximum == (double)-1) && PyErr_Occurred())) __PYX_ERR(2, 4375, __pyx_L3_error)
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[3]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4045, __pyx_L3_error)
     } else {
-      __pyx_v_maximum = ((double)0.2);
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
     }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("SAR", 0, 2, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 4375, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("MINUS_DI", 0, 3, 4, __pyx_nargs); __PYX_ERR(4, 4043, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.SAR", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.MINUS_DI", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(2, 4375, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(2, 4375, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_282SAR(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_acceleration, __pyx_v_maximum);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 4045, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 4045, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 4045, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_260MINUS_DI(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_timeperiod);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_282SAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, double __pyx_v_acceleration, double __pyx_v_maximum) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_260MINUS_DI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -27305,43 +32956,52 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_282SAR(CYTHON_UNUSED PyObject *__pyx_s
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
   npy_int __pyx_t_3;
-  __Pyx_RefNannySetupContext("SAR", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("MINUS_DI", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
+  __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4395, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4064, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4396, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4065, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_high, __pyx_v_low); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(2, 4397, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4066, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
+
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 4067, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
-  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx2(__pyx_v_length, ((double *)__pyx_v_high->data), ((double *)__pyx_v_low->data)); if (unlikely(__pyx_t_3 == ((npy_int)-1))) __PYX_ERR(2, 4398, __pyx_L1_error)
+  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx3(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4068, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_3;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_SAR_Lookback(__pyx_v_acceleration, __pyx_v_maximum));
+  __pyx_v_lookback = (__pyx_v_begidx + TA_MINUS_DI_Lookback(__pyx_v_timeperiod));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4401, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4071, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_SAR(0, __pyx_v_endidx, (((double *)__pyx_v_high->data) + __pyx_v_begidx), (((double *)__pyx_v_low->data) + __pyx_v_begidx), __pyx_v_acceleration, __pyx_v_maximum, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_v_outreal->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_MINUS_DI(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_SAR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4403, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_MINUS_DI, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4073, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outreal));
+  __Pyx_INCREF((PyObject *)__pyx_v_outreal);
   __pyx_r = ((PyObject *)__pyx_v_outreal);
   goto __pyx_L0;
 
@@ -27349,12 +33009,13 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_282SAR(CYTHON_UNUSED PyObject *__pyx_s
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.SAR", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.MINUS_DI", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
   __Pyx_XDECREF((PyObject *)__pyx_v_high);
   __Pyx_XDECREF((PyObject *)__pyx_v_low);
+  __Pyx_XDECREF((PyObject *)__pyx_v_close);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -27362,136 +33023,81 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_282SAR(CYTHON_UNUSED PyObject *__pyx_s
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_285SAREXT(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_284SAREXT[] = " SAREXT(high, low[, startvalue=?, offsetonreverse=?, accelerationinitlong=?, accelerationlong=?, accelerationmaxlong=?, accelerationinitshort=?, accelerationshort=?, accelerationmaxshort=?])\n\n    Parabolic SAR - Extended (Overlap Studies)\n\n    Inputs:\n        prices: ['high', 'low']\n    Parameters:\n        startvalue: 0\n        offsetonreverse: 0\n        accelerationinitlong: 0.02\n        accelerationlong: 0.02\n        accelerationmaxlong: 0.2\n        accelerationinitshort: 0.02\n        accelerationshort: 0.02\n        accelerationmaxshort: 0.2\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_285SAREXT = {"SAREXT", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_285SAREXT, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_284SAREXT};
-static PyObject *__pyx_pw_5talib_7_ta_lib_285SAREXT(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_263MINUS_DM(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_262MINUS_DM, "MINUS_DM(ndarray high, ndarray low, int timeperiod=-0x80000000)\n\nMINUS_DM(high, low[, timeperiod=?])\n\nMinus Directional Movement (Momentum Indicators)\n\nInputs:\n    prices: ['high', 'low']\nParameters:\n    timeperiod: 14\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_263MINUS_DM = {"MINUS_DM", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_263MINUS_DM, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_262MINUS_DM};
+static PyObject *__pyx_pw_5talib_7_ta_lib_263MINUS_DM(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
-  double __pyx_v_startvalue;
-  double __pyx_v_offsetonreverse;
-  double __pyx_v_accelerationinitlong;
-  double __pyx_v_accelerationlong;
-  double __pyx_v_accelerationmaxlong;
-  double __pyx_v_accelerationinitshort;
-  double __pyx_v_accelerationshort;
-  double __pyx_v_accelerationmaxshort;
+  int __pyx_v_timeperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[3] = {0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("SAREXT (wrapper)", 0);
+  __Pyx_RefNannySetupContext("MINUS_DM (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_startvalue,&__pyx_n_s_offsetonreverse,&__pyx_n_s_accelerationinitlong,&__pyx_n_s_accelerationlong,&__pyx_n_s_accelerationmaxlong,&__pyx_n_s_accelerationinitshort,&__pyx_n_s_accelerationshort,&__pyx_n_s_accelerationmaxshort,0};
-    PyObject* values[10] = {0,0,0,0,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 10: values[9] = PyTuple_GET_ITEM(__pyx_args, 9);
-        CYTHON_FALLTHROUGH;
-        case  9: values[8] = PyTuple_GET_ITEM(__pyx_args, 8);
-        CYTHON_FALLTHROUGH;
-        case  8: values[7] = PyTuple_GET_ITEM(__pyx_args, 7);
-        CYTHON_FALLTHROUGH;
-        case  7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6);
-        CYTHON_FALLTHROUGH;
-        case  6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
-        CYTHON_FALLTHROUGH;
-        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
-        CYTHON_FALLTHROUGH;
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_timeperiod,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 4076, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 4076, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 4076, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4076, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("SAREXT", 0, 2, 10, 1); __PYX_ERR(2, 4408, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_startvalue);
-          if (value) { values[2] = value; kw_args--; }
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_offsetonreverse);
-          if (value) { values[3] = value; kw_args--; }
-        }
-        CYTHON_FALLTHROUGH;
-        case  4:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_accelerationinitlong);
-          if (value) { values[4] = value; kw_args--; }
-        }
-        CYTHON_FALLTHROUGH;
-        case  5:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_accelerationlong);
-          if (value) { values[5] = value; kw_args--; }
-        }
-        CYTHON_FALLTHROUGH;
-        case  6:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_accelerationmaxlong);
-          if (value) { values[6] = value; kw_args--; }
-        }
-        CYTHON_FALLTHROUGH;
-        case  7:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_accelerationinitshort);
-          if (value) { values[7] = value; kw_args--; }
-        }
-        CYTHON_FALLTHROUGH;
-        case  8:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_accelerationshort);
-          if (value) { values[8] = value; kw_args--; }
-        }
-        CYTHON_FALLTHROUGH;
-        case  9:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_accelerationmaxshort);
-          if (value) { values[9] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "SAREXT") < 0)) __PYX_ERR(2, 4408, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "MINUS_DM", 0) < (0)) __PYX_ERR(4, 4076, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("MINUS_DM", 0, 2, 3, i); __PYX_ERR(4, 4076, __pyx_L3_error) }
       }
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case 10: values[9] = PyTuple_GET_ITEM(__pyx_args, 9);
-        CYTHON_FALLTHROUGH;
-        case  9: values[8] = PyTuple_GET_ITEM(__pyx_args, 8);
-        CYTHON_FALLTHROUGH;
-        case  8: values[7] = PyTuple_GET_ITEM(__pyx_args, 7);
-        CYTHON_FALLTHROUGH;
-        case  7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6);
-        CYTHON_FALLTHROUGH;
-        case  6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
-        CYTHON_FALLTHROUGH;
-        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
-        CYTHON_FALLTHROUGH;
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+      switch (__pyx_nargs) {
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 4076, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 4076, __pyx_L3_error)
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4076, __pyx_L3_error)
         break;
         default: goto __pyx_L5_argtuple_error;
       }
@@ -27499,68 +33105,46 @@ static PyObject *__pyx_pw_5talib_7_ta_lib_285SAREXT(PyObject *__pyx_self, PyObje
     __pyx_v_high = ((PyArrayObject *)values[0]);
     __pyx_v_low = ((PyArrayObject *)values[1]);
     if (values[2]) {
-      __pyx_v_startvalue = __pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_startvalue == (double)-1) && PyErr_Occurred())) __PYX_ERR(2, 4408, __pyx_L3_error)
-    } else {
-      __pyx_v_startvalue = ((double)-4e37);
-    }
-    if (values[3]) {
-      __pyx_v_offsetonreverse = __pyx_PyFloat_AsDouble(values[3]); if (unlikely((__pyx_v_offsetonreverse == (double)-1) && PyErr_Occurred())) __PYX_ERR(2, 4408, __pyx_L3_error)
-    } else {
-      __pyx_v_offsetonreverse = ((double)-4e37);
-    }
-    if (values[4]) {
-      __pyx_v_accelerationinitlong = __pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_accelerationinitlong == (double)-1) && PyErr_Occurred())) __PYX_ERR(2, 4408, __pyx_L3_error)
-    } else {
-      __pyx_v_accelerationinitlong = ((double)-4e37);
-    }
-    if (values[5]) {
-      __pyx_v_accelerationlong = __pyx_PyFloat_AsDouble(values[5]); if (unlikely((__pyx_v_accelerationlong == (double)-1) && PyErr_Occurred())) __PYX_ERR(2, 4408, __pyx_L3_error)
-    } else {
-      __pyx_v_accelerationlong = ((double)-4e37);
-    }
-    if (values[6]) {
-      __pyx_v_accelerationmaxlong = __pyx_PyFloat_AsDouble(values[6]); if (unlikely((__pyx_v_accelerationmaxlong == (double)-1) && PyErr_Occurred())) __PYX_ERR(2, 4408, __pyx_L3_error)
-    } else {
-      __pyx_v_accelerationmaxlong = ((double)-4e37);
-    }
-    if (values[7]) {
-      __pyx_v_accelerationinitshort = __pyx_PyFloat_AsDouble(values[7]); if (unlikely((__pyx_v_accelerationinitshort == (double)-1) && PyErr_Occurred())) __PYX_ERR(2, 4408, __pyx_L3_error)
-    } else {
-      __pyx_v_accelerationinitshort = ((double)-4e37);
-    }
-    if (values[8]) {
-      __pyx_v_accelerationshort = __pyx_PyFloat_AsDouble(values[8]); if (unlikely((__pyx_v_accelerationshort == (double)-1) && PyErr_Occurred())) __PYX_ERR(2, 4408, __pyx_L3_error)
-    } else {
-      __pyx_v_accelerationshort = ((double)-4e37);
-    }
-    if (values[9]) {
-      __pyx_v_accelerationmaxshort = __pyx_PyFloat_AsDouble(values[9]); if (unlikely((__pyx_v_accelerationmaxshort == (double)-1) && PyErr_Occurred())) __PYX_ERR(2, 4408, __pyx_L3_error)
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[2]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4078, __pyx_L3_error)
     } else {
-      __pyx_v_accelerationmaxshort = ((double)-4e37);
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
     }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("SAREXT", 0, 2, 10, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 4408, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("MINUS_DM", 0, 2, 3, __pyx_nargs); __PYX_ERR(4, 4076, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.SAREXT", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.MINUS_DM", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(2, 4408, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(2, 4408, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_284SAREXT(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_startvalue, __pyx_v_offsetonreverse, __pyx_v_accelerationinitlong, __pyx_v_accelerationlong, __pyx_v_accelerationmaxlong, __pyx_v_accelerationinitshort, __pyx_v_accelerationshort, __pyx_v_accelerationmaxshort);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 4078, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 4078, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_262MINUS_DM(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_timeperiod);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_284SAREXT(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, double __pyx_v_startvalue, double __pyx_v_offsetonreverse, double __pyx_v_accelerationinitlong, double __pyx_v_accelerationlong, double __pyx_v_accelerationmaxlong, double __pyx_v_accelerationinitshort, double __pyx_v_accelerationshort, double __pyx_v_accelerationmaxshort) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_262MINUS_DM(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, int __pyx_v_timeperiod) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -27574,43 +33158,46 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_284SAREXT(CYTHON_UNUSED PyObject *__py
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
   npy_int __pyx_t_3;
-  __Pyx_RefNannySetupContext("SAREXT", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("MINUS_DM", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4434, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4097, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4435, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4098, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_high, __pyx_v_low); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(2, 4436, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_high, __pyx_v_low); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 4099, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
-  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx2(__pyx_v_length, ((double *)__pyx_v_high->data), ((double *)__pyx_v_low->data)); if (unlikely(__pyx_t_3 == ((npy_int)-1))) __PYX_ERR(2, 4437, __pyx_L1_error)
+  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx2(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4100, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_3;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_SAREXT_Lookback(__pyx_v_startvalue, __pyx_v_offsetonreverse, __pyx_v_accelerationinitlong, __pyx_v_accelerationlong, __pyx_v_accelerationmaxlong, __pyx_v_accelerationinitshort, __pyx_v_accelerationshort, __pyx_v_accelerationmaxshort));
+  __pyx_v_lookback = (__pyx_v_begidx + TA_MINUS_DM_Lookback(__pyx_v_timeperiod));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4440, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4103, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_SAREXT(0, __pyx_v_endidx, (((double *)__pyx_v_high->data) + __pyx_v_begidx), (((double *)__pyx_v_low->data) + __pyx_v_begidx), __pyx_v_startvalue, __pyx_v_offsetonreverse, __pyx_v_accelerationinitlong, __pyx_v_accelerationlong, __pyx_v_accelerationmaxlong, __pyx_v_accelerationinitshort, __pyx_v_accelerationshort, __pyx_v_accelerationmaxshort, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_v_outreal->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_MINUS_DM(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_SAREXT, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4442, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_MINUS_DM, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4105, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outreal));
+  __Pyx_INCREF((PyObject *)__pyx_v_outreal);
   __pyx_r = ((PyObject *)__pyx_v_outreal);
   goto __pyx_L0;
 
@@ -27618,7 +33205,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_284SAREXT(CYTHON_UNUSED PyObject *__py
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.SAREXT", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.MINUS_DM", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
@@ -27631,26 +33218,119 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_284SAREXT(CYTHON_UNUSED PyObject *__py
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_287SIN(PyObject *__pyx_self, PyObject *__pyx_v_real); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_286SIN[] = " SIN(real)\n\n    Vector Trigonometric Sin (Math Transform)\n\n    Inputs:\n        real: (any ndarray)\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_287SIN = {"SIN", (PyCFunction)__pyx_pw_5talib_7_ta_lib_287SIN, METH_O, __pyx_doc_5talib_7_ta_lib_286SIN};
-static PyObject *__pyx_pw_5talib_7_ta_lib_287SIN(PyObject *__pyx_self, PyObject *__pyx_v_real) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_265MOM(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_264MOM, "MOM(ndarray real, int timeperiod=-0x80000000)\n\nMOM(real[, timeperiod=?])\n\nMomentum (Momentum Indicators)\n\nInputs:\n    real: (any ndarray)\nParameters:\n    timeperiod: 10\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_265MOM = {"MOM", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_265MOM, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_264MOM};
+static PyObject *__pyx_pw_5talib_7_ta_lib_265MOM(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_real = 0;
+  int __pyx_v_timeperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("SIN (wrapper)", 0);
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(2, 4447, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_286SIN(__pyx_self, ((PyArrayObject *)__pyx_v_real));
+  __Pyx_RefNannySetupContext("MOM (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 4108, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 4108, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4108, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "MOM", 0) < (0)) __PYX_ERR(4, 4108, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("MOM", 0, 1, 2, i); __PYX_ERR(4, 4108, __pyx_L3_error) }
+      }
+    } else {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 4108, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4108, __pyx_L3_error)
+        break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+    }
+    __pyx_v_real = ((PyArrayObject *)values[0]);
+    if (values[1]) {
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4110, __pyx_L3_error)
+    } else {
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
+    }
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("MOM", 0, 1, 2, __pyx_nargs); __PYX_ERR(4, 4108, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.MOM", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 4110, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_264MOM(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_286SIN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_264MOM(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -27663,36 +33343,39 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_286SIN(CYTHON_UNUSED PyObject *__pyx_s
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_int __pyx_t_2;
-  __Pyx_RefNannySetupContext("SIN", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("MOM", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4464, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4129, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_v_real->data)); if (unlikely(__pyx_t_2 == ((npy_int)-1))) __PYX_ERR(2, 4466, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4131, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_2;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_SIN_Lookback());
+  __pyx_v_lookback = (__pyx_v_begidx + TA_MOM_Lookback(__pyx_v_timeperiod));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4469, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4134, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_SIN(0, __pyx_v_endidx, (((double *)__pyx_v_real->data) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_v_outreal->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_MOM(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_SIN, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4471, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_MOM, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4136, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outreal));
+  __Pyx_INCREF((PyObject *)__pyx_v_outreal);
   __pyx_r = ((PyObject *)__pyx_v_outreal);
   goto __pyx_L0;
 
@@ -27700,7 +33383,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_286SIN(CYTHON_UNUSED PyObject *__pyx_s
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.SIN", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.MOM", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
@@ -27712,26 +33395,111 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_286SIN(CYTHON_UNUSED PyObject *__pyx_s
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_289SINH(PyObject *__pyx_self, PyObject *__pyx_v_real); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_288SINH[] = " SINH(real)\n\n    Vector Trigonometric Sinh (Math Transform)\n\n    Inputs:\n        real: (any ndarray)\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_289SINH = {"SINH", (PyCFunction)__pyx_pw_5talib_7_ta_lib_289SINH, METH_O, __pyx_doc_5talib_7_ta_lib_288SINH};
-static PyObject *__pyx_pw_5talib_7_ta_lib_289SINH(PyObject *__pyx_self, PyObject *__pyx_v_real) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_267MULT(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_266MULT, "MULT(ndarray real0, ndarray real1)\n\nMULT(real0, real1)\n\nVector Arithmetic Mult (Math Operators)\n\nInputs:\n    real0: (any ndarray)\n    real1: (any ndarray)\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_267MULT = {"MULT", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_267MULT, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_266MULT};
+static PyObject *__pyx_pw_5talib_7_ta_lib_267MULT(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_real0 = 0;
+  PyArrayObject *__pyx_v_real1 = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("SINH (wrapper)", 0);
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(2, 4476, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_288SINH(__pyx_self, ((PyArrayObject *)__pyx_v_real));
+  __Pyx_RefNannySetupContext("MULT (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real0,&__pyx_mstate_global->__pyx_n_u_real1,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 4139, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 4139, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4139, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "MULT", 0) < (0)) __PYX_ERR(4, 4139, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("MULT", 1, 2, 2, i); __PYX_ERR(4, 4139, __pyx_L3_error) }
+      }
+    } else if (unlikely(__pyx_nargs != 2)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4139, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 4139, __pyx_L3_error)
+    }
+    __pyx_v_real0 = ((PyArrayObject *)values[0]);
+    __pyx_v_real1 = ((PyArrayObject *)values[1]);
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("MULT", 1, 2, 2, __pyx_nargs); __PYX_ERR(4, 4139, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.MULT", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real0), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real0", 0))) __PYX_ERR(4, 4141, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real1), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real1", 0))) __PYX_ERR(4, 4141, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_266MULT(__pyx_self, __pyx_v_real0, __pyx_v_real1);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_288SINH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_266MULT(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real0, PyArrayObject *__pyx_v_real1) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -27743,37 +33511,48 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_288SINH(CYTHON_UNUSED PyObject *__pyx_
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  npy_int __pyx_t_2;
-  __Pyx_RefNannySetupContext("SINH", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_real);
+  npy_intp __pyx_t_2;
+  npy_int __pyx_t_3;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("MULT", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_real0);
+  __Pyx_INCREF((PyObject *)__pyx_v_real1);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4493, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4159, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_real0, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
+
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4160, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_real1, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_real0, __pyx_v_real1); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 4161, __pyx_L1_error)
+  __pyx_v_length = __pyx_t_2;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_v_real->data)); if (unlikely(__pyx_t_2 == ((npy_int)-1))) __PYX_ERR(2, 4495, __pyx_L1_error)
-  __pyx_v_begidx = __pyx_t_2;
+  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx2(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real0)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real1))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4162, __pyx_L1_error)
+  __pyx_v_begidx = __pyx_t_3;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_SINH_Lookback());
+  __pyx_v_lookback = (__pyx_v_begidx + TA_MULT_Lookback());
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4498, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4165, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_SINH(0, __pyx_v_endidx, (((double *)__pyx_v_real->data) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_v_outreal->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_MULT(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real0)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real1)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_SINH, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4500, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_MULT, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4167, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outreal));
+  __Pyx_INCREF((PyObject *)__pyx_v_outreal);
   __pyx_r = ((PyObject *)__pyx_v_outreal);
   goto __pyx_L0;
 
@@ -27781,11 +33560,12 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_288SINH(CYTHON_UNUSED PyObject *__pyx_
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.SINH", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.MULT", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
-  __Pyx_XDECREF((PyObject *)__pyx_v_real);
+  __Pyx_XDECREF((PyObject *)__pyx_v_real0);
+  __Pyx_XDECREF((PyObject *)__pyx_v_real1);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -27793,81 +33573,137 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_288SINH(CYTHON_UNUSED PyObject *__pyx_
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_291SMA(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_290SMA[] = " SMA(real[, timeperiod=?])\n\n    Simple Moving Average (Overlap Studies)\n\n    Inputs:\n        real: (any ndarray)\n    Parameters:\n        timeperiod: 30\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_291SMA = {"SMA", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_291SMA, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_290SMA};
-static PyObject *__pyx_pw_5talib_7_ta_lib_291SMA(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_real = 0;
+static PyObject *__pyx_pw_5talib_7_ta_lib_269NATR(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_268NATR, "NATR(ndarray high, ndarray low, ndarray close, int timeperiod=-0x80000000)\n\nNATR(high, low, close[, timeperiod=?])\n\nNormalized Average True Range (Volatility Indicators)\n\nInputs:\n    prices: ['high', 'low', 'close']\nParameters:\n    timeperiod: 14\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_269NATR = {"NATR", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_269NATR, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_268NATR};
+static PyObject *__pyx_pw_5talib_7_ta_lib_269NATR(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_high = 0;
+  PyArrayObject *__pyx_v_low = 0;
+  PyArrayObject *__pyx_v_close = 0;
   int __pyx_v_timeperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("SMA (wrapper)", 0);
+  __Pyx_RefNannySetupContext("NATR (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,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);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,&__pyx_mstate_global->__pyx_n_u_timeperiod,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 4170, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 4170, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 4170, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  0: break;
-        default: goto __pyx_L5_argtuple_error;
-      }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 4170, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  1:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod);
-          if (value) { values[1] = value; kw_args--; }
-        }
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4170, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
       }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "SMA") < 0)) __PYX_ERR(2, 4505, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "NATR", 0) < (0)) __PYX_ERR(4, 4170, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 3; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("NATR", 0, 3, 4, i); __PYX_ERR(4, 4170, __pyx_L3_error) }
       }
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 4170, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 4170, __pyx_L3_error)
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 4170, __pyx_L3_error)
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4170, __pyx_L3_error)
         break;
         default: goto __pyx_L5_argtuple_error;
       }
     }
-    __pyx_v_real = ((PyArrayObject *)values[0]);
-    if (values[1]) {
-      __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 4505, __pyx_L3_error)
+    __pyx_v_high = ((PyArrayObject *)values[0]);
+    __pyx_v_low = ((PyArrayObject *)values[1]);
+    __pyx_v_close = ((PyArrayObject *)values[2]);
+    if (values[3]) {
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[3]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4172, __pyx_L3_error)
     } else {
-      __pyx_v_timeperiod = ((int)-2147483648);
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
     }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("SMA", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 4505, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("NATR", 0, 3, 4, __pyx_nargs); __PYX_ERR(4, 4170, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.SMA", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.NATR", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(2, 4505, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_290SMA(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 4172, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 4172, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 4172, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_268NATR(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_timeperiod);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_290SMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_268NATR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -27879,37 +33715,54 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_290SMA(CYTHON_UNUSED PyObject *__pyx_s
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  npy_int __pyx_t_2;
-  __Pyx_RefNannySetupContext("SMA", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_real);
+  npy_intp __pyx_t_2;
+  npy_int __pyx_t_3;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("NATR", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_high);
+  __Pyx_INCREF((PyObject *)__pyx_v_low);
+  __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4524, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4191, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
+
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4192, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4193, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_v_real->data)); if (unlikely(__pyx_t_2 == ((npy_int)-1))) __PYX_ERR(2, 4526, __pyx_L1_error)
-  __pyx_v_begidx = __pyx_t_2;
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 4194, __pyx_L1_error)
+  __pyx_v_length = __pyx_t_2;
+
+  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx3(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4195, __pyx_L1_error)
+  __pyx_v_begidx = __pyx_t_3;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_SMA_Lookback(__pyx_v_timeperiod));
+  __pyx_v_lookback = (__pyx_v_begidx + TA_NATR_Lookback(__pyx_v_timeperiod));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4529, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4198, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_SMA(0, __pyx_v_endidx, (((double *)__pyx_v_real->data) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_v_outreal->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_NATR(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_SMA, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4531, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_NATR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4200, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outreal));
+  __Pyx_INCREF((PyObject *)__pyx_v_outreal);
   __pyx_r = ((PyObject *)__pyx_v_outreal);
   goto __pyx_L0;
 
@@ -27917,11 +33770,13 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_290SMA(CYTHON_UNUSED PyObject *__pyx_s
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.SMA", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.NATR", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
-  __Pyx_XDECREF((PyObject *)__pyx_v_real);
+  __Pyx_XDECREF((PyObject *)__pyx_v_high);
+  __Pyx_XDECREF((PyObject *)__pyx_v_low);
+  __Pyx_XDECREF((PyObject *)__pyx_v_close);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -27929,26 +33784,111 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_290SMA(CYTHON_UNUSED PyObject *__pyx_s
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_293SQRT(PyObject *__pyx_self, PyObject *__pyx_v_real); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_292SQRT[] = " SQRT(real)\n\n    Vector Square Root (Math Transform)\n\n    Inputs:\n        real: (any ndarray)\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_293SQRT = {"SQRT", (PyCFunction)__pyx_pw_5talib_7_ta_lib_293SQRT, METH_O, __pyx_doc_5talib_7_ta_lib_292SQRT};
-static PyObject *__pyx_pw_5talib_7_ta_lib_293SQRT(PyObject *__pyx_self, PyObject *__pyx_v_real) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_271OBV(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_270OBV, "OBV(ndarray real, ndarray volume)\n\nOBV(real, volume)\n\nOn Balance Volume (Volume Indicators)\n\nInputs:\n    real: (any ndarray)\n    prices: ['volume']\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_271OBV = {"OBV", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_271OBV, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_270OBV};
+static PyObject *__pyx_pw_5talib_7_ta_lib_271OBV(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_real = 0;
+  PyArrayObject *__pyx_v_volume = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("SQRT (wrapper)", 0);
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(2, 4536, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_292SQRT(__pyx_self, ((PyArrayObject *)__pyx_v_real));
+  __Pyx_RefNannySetupContext("OBV (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_volume,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 4203, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 4203, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4203, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "OBV", 0) < (0)) __PYX_ERR(4, 4203, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("OBV", 1, 2, 2, i); __PYX_ERR(4, 4203, __pyx_L3_error) }
+      }
+    } else if (unlikely(__pyx_nargs != 2)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4203, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 4203, __pyx_L3_error)
+    }
+    __pyx_v_real = ((PyArrayObject *)values[0]);
+    __pyx_v_volume = ((PyArrayObject *)values[1]);
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("OBV", 1, 2, 2, __pyx_nargs); __PYX_ERR(4, 4203, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.OBV", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 4205, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_volume), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "volume", 0))) __PYX_ERR(4, 4205, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_270OBV(__pyx_self, __pyx_v_real, __pyx_v_volume);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_292SQRT(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_270OBV(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, PyArrayObject *__pyx_v_volume) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -27960,37 +33900,48 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_292SQRT(CYTHON_UNUSED PyObject *__pyx_
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  npy_int __pyx_t_2;
-  __Pyx_RefNannySetupContext("SQRT", 0);
+  npy_intp __pyx_t_2;
+  npy_int __pyx_t_3;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("OBV", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_real);
+  __Pyx_INCREF((PyObject *)__pyx_v_volume);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4553, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4223, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_volume)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4224, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_volume, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
+
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_real, __pyx_v_volume); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 4225, __pyx_L1_error)
+  __pyx_v_length = __pyx_t_2;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_v_real->data)); if (unlikely(__pyx_t_2 == ((npy_int)-1))) __PYX_ERR(2, 4555, __pyx_L1_error)
-  __pyx_v_begidx = __pyx_t_2;
+  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx2(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_volume))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4226, __pyx_L1_error)
+  __pyx_v_begidx = __pyx_t_3;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_SQRT_Lookback());
+  __pyx_v_lookback = (__pyx_v_begidx + TA_OBV_Lookback());
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4558, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4229, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_SQRT(0, __pyx_v_endidx, (((double *)__pyx_v_real->data) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_v_outreal->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_OBV(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_volume)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_SQRT, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4560, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_OBV, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4231, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outreal));
+  __Pyx_INCREF((PyObject *)__pyx_v_outreal);
   __pyx_r = ((PyObject *)__pyx_v_outreal);
   goto __pyx_L0;
 
@@ -27998,11 +33949,12 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_292SQRT(CYTHON_UNUSED PyObject *__pyx_
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.SQRT", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.OBV", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
   __Pyx_XDECREF((PyObject *)__pyx_v_real);
+  __Pyx_XDECREF((PyObject *)__pyx_v_volume);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -28010,97 +33962,137 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_292SQRT(CYTHON_UNUSED PyObject *__pyx_
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_295STDDEV(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_294STDDEV[] = " STDDEV(real[, timeperiod=?, nbdev=?])\n\n    Standard Deviation (Statistic Functions)\n\n    Inputs:\n        real: (any ndarray)\n    Parameters:\n        timeperiod: 5\n        nbdev: 1\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_295STDDEV = {"STDDEV", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_295STDDEV, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_294STDDEV};
-static PyObject *__pyx_pw_5talib_7_ta_lib_295STDDEV(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_real = 0;
+static PyObject *__pyx_pw_5talib_7_ta_lib_273PLUS_DI(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_272PLUS_DI, "PLUS_DI(ndarray high, ndarray low, ndarray close, int timeperiod=-0x80000000)\n\nPLUS_DI(high, low, close[, timeperiod=?])\n\nPlus Directional Indicator (Momentum Indicators)\n\nInputs:\n    prices: ['high', 'low', 'close']\nParameters:\n    timeperiod: 14\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_273PLUS_DI = {"PLUS_DI", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_273PLUS_DI, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_272PLUS_DI};
+static PyObject *__pyx_pw_5talib_7_ta_lib_273PLUS_DI(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_high = 0;
+  PyArrayObject *__pyx_v_low = 0;
+  PyArrayObject *__pyx_v_close = 0;
   int __pyx_v_timeperiod;
-  double __pyx_v_nbdev;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("STDDEV (wrapper)", 0);
+  __Pyx_RefNannySetupContext("PLUS_DI (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,&__pyx_n_s_nbdev,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);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,&__pyx_mstate_global->__pyx_n_u_timeperiod,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 4234, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 4234, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 4234, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  0: break;
-        default: goto __pyx_L5_argtuple_error;
-      }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 4234, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  1:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod);
-          if (value) { values[1] = value; kw_args--; }
-        }
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4234, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_nbdev);
-          if (value) { values[2] = value; kw_args--; }
-        }
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
       }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "STDDEV") < 0)) __PYX_ERR(2, 4565, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "PLUS_DI", 0) < (0)) __PYX_ERR(4, 4234, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 3; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("PLUS_DI", 0, 3, 4, i); __PYX_ERR(4, 4234, __pyx_L3_error) }
       }
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 4234, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 4234, __pyx_L3_error)
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 4234, __pyx_L3_error)
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4234, __pyx_L3_error)
         break;
         default: goto __pyx_L5_argtuple_error;
       }
     }
-    __pyx_v_real = ((PyArrayObject *)values[0]);
-    if (values[1]) {
-      __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 4565, __pyx_L3_error)
-    } else {
-      __pyx_v_timeperiod = ((int)-2147483648);
-    }
-    if (values[2]) {
-      __pyx_v_nbdev = __pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_nbdev == (double)-1) && PyErr_Occurred())) __PYX_ERR(2, 4565, __pyx_L3_error)
+    __pyx_v_high = ((PyArrayObject *)values[0]);
+    __pyx_v_low = ((PyArrayObject *)values[1]);
+    __pyx_v_close = ((PyArrayObject *)values[2]);
+    if (values[3]) {
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[3]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4236, __pyx_L3_error)
     } else {
-      __pyx_v_nbdev = ((double)-4e37);
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
     }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("STDDEV", 0, 1, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 4565, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("PLUS_DI", 0, 3, 4, __pyx_nargs); __PYX_ERR(4, 4234, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.STDDEV", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.PLUS_DI", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(2, 4565, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_294STDDEV(__pyx_self, __pyx_v_real, __pyx_v_timeperiod, __pyx_v_nbdev);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 4236, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 4236, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 4236, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_272PLUS_DI(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_timeperiod);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_294STDDEV(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod, double __pyx_v_nbdev) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_272PLUS_DI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -28112,37 +34104,54 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_294STDDEV(CYTHON_UNUSED PyObject *__py
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  npy_int __pyx_t_2;
-  __Pyx_RefNannySetupContext("STDDEV", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_real);
+  npy_intp __pyx_t_2;
+  npy_int __pyx_t_3;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("PLUS_DI", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_high);
+  __Pyx_INCREF((PyObject *)__pyx_v_low);
+  __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4585, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4255, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4256, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_v_real->data)); if (unlikely(__pyx_t_2 == ((npy_int)-1))) __PYX_ERR(2, 4587, __pyx_L1_error)
-  __pyx_v_begidx = __pyx_t_2;
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4257, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
+
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 4258, __pyx_L1_error)
+  __pyx_v_length = __pyx_t_2;
+
+  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx3(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4259, __pyx_L1_error)
+  __pyx_v_begidx = __pyx_t_3;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_STDDEV_Lookback(__pyx_v_timeperiod, __pyx_v_nbdev));
+  __pyx_v_lookback = (__pyx_v_begidx + TA_PLUS_DI_Lookback(__pyx_v_timeperiod));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4590, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4262, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_STDDEV(0, __pyx_v_endidx, (((double *)__pyx_v_real->data) + __pyx_v_begidx), __pyx_v_timeperiod, __pyx_v_nbdev, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_v_outreal->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_PLUS_DI(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_STDDEV, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4592, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_PLUS_DI, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4264, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outreal));
+  __Pyx_INCREF((PyObject *)__pyx_v_outreal);
   __pyx_r = ((PyObject *)__pyx_v_outreal);
   goto __pyx_L0;
 
@@ -28150,11 +34159,13 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_294STDDEV(CYTHON_UNUSED PyObject *__py
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.STDDEV", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.PLUS_DI", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
-  __Pyx_XDECREF((PyObject *)__pyx_v_real);
+  __Pyx_XDECREF((PyObject *)__pyx_v_high);
+  __Pyx_XDECREF((PyObject *)__pyx_v_low);
+  __Pyx_XDECREF((PyObject *)__pyx_v_close);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -28162,169 +34173,128 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_294STDDEV(CYTHON_UNUSED PyObject *__py
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_297STOCH(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_296STOCH[] = " STOCH(high, low, close[, fastk_period=?, slowk_period=?, slowk_matype=?, slowd_period=?, slowd_matype=?])\n\n    Stochastic (Momentum Indicators)\n\n    Inputs:\n        prices: ['high', 'low', 'close']\n    Parameters:\n        fastk_period: 5\n        slowk_period: 3\n        slowk_matype: 0\n        slowd_period: 3\n        slowd_matype: 0\n    Outputs:\n        slowk\n        slowd\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_297STOCH = {"STOCH", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_297STOCH, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_296STOCH};
-static PyObject *__pyx_pw_5talib_7_ta_lib_297STOCH(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_275PLUS_DM(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_274PLUS_DM, "PLUS_DM(ndarray high, ndarray low, int timeperiod=-0x80000000)\n\nPLUS_DM(high, low[, timeperiod=?])\n\nPlus Directional Movement (Momentum Indicators)\n\nInputs:\n    prices: ['high', 'low']\nParameters:\n    timeperiod: 14\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_275PLUS_DM = {"PLUS_DM", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_275PLUS_DM, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_274PLUS_DM};
+static PyObject *__pyx_pw_5talib_7_ta_lib_275PLUS_DM(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
-  PyArrayObject *__pyx_v_close = 0;
-  int __pyx_v_fastk_period;
-  int __pyx_v_slowk_period;
-  int __pyx_v_slowk_matype;
-  int __pyx_v_slowd_period;
-  int __pyx_v_slowd_matype;
+  int __pyx_v_timeperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[3] = {0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("STOCH (wrapper)", 0);
+  __Pyx_RefNannySetupContext("PLUS_DM (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,&__pyx_n_s_fastk_period,&__pyx_n_s_slowk_period,&__pyx_n_s_slowk_matype,&__pyx_n_s_slowd_period,&__pyx_n_s_slowd_matype,0};
-    PyObject* values[8] = {0,0,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  8: values[7] = PyTuple_GET_ITEM(__pyx_args, 7);
-        CYTHON_FALLTHROUGH;
-        case  7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6);
-        CYTHON_FALLTHROUGH;
-        case  6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
-        CYTHON_FALLTHROUGH;
-        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
-        CYTHON_FALLTHROUGH;
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_timeperiod,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 4267, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 4267, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 4267, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4267, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("STOCH", 0, 3, 8, 1); __PYX_ERR(2, 4597, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("STOCH", 0, 3, 8, 2); __PYX_ERR(2, 4597, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_fastk_period);
-          if (value) { values[3] = value; kw_args--; }
-        }
-        CYTHON_FALLTHROUGH;
-        case  4:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_slowk_period);
-          if (value) { values[4] = value; kw_args--; }
-        }
-        CYTHON_FALLTHROUGH;
-        case  5:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_slowk_matype);
-          if (value) { values[5] = value; kw_args--; }
-        }
-        CYTHON_FALLTHROUGH;
-        case  6:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_slowd_period);
-          if (value) { values[6] = value; kw_args--; }
-        }
-        CYTHON_FALLTHROUGH;
-        case  7:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_slowd_matype);
-          if (value) { values[7] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "STOCH") < 0)) __PYX_ERR(2, 4597, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "PLUS_DM", 0) < (0)) __PYX_ERR(4, 4267, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("PLUS_DM", 0, 2, 3, i); __PYX_ERR(4, 4267, __pyx_L3_error) }
       }
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  8: values[7] = PyTuple_GET_ITEM(__pyx_args, 7);
-        CYTHON_FALLTHROUGH;
-        case  7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6);
-        CYTHON_FALLTHROUGH;
-        case  6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
-        CYTHON_FALLTHROUGH;
-        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
-        CYTHON_FALLTHROUGH;
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+      switch (__pyx_nargs) {
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 4267, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 4267, __pyx_L3_error)
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4267, __pyx_L3_error)
         break;
         default: goto __pyx_L5_argtuple_error;
       }
     }
     __pyx_v_high = ((PyArrayObject *)values[0]);
     __pyx_v_low = ((PyArrayObject *)values[1]);
-    __pyx_v_close = ((PyArrayObject *)values[2]);
-    if (values[3]) {
-      __pyx_v_fastk_period = __Pyx_PyInt_As_int(values[3]); if (unlikely((__pyx_v_fastk_period == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 4597, __pyx_L3_error)
-    } else {
-      __pyx_v_fastk_period = ((int)-2147483648);
-    }
-    if (values[4]) {
-      __pyx_v_slowk_period = __Pyx_PyInt_As_int(values[4]); if (unlikely((__pyx_v_slowk_period == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 4597, __pyx_L3_error)
-    } else {
-      __pyx_v_slowk_period = ((int)-2147483648);
-    }
-    if (values[5]) {
-      __pyx_v_slowk_matype = __Pyx_PyInt_As_int(values[5]); if (unlikely((__pyx_v_slowk_matype == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 4597, __pyx_L3_error)
-    } else {
-      __pyx_v_slowk_matype = ((int)0);
-    }
-    if (values[6]) {
-      __pyx_v_slowd_period = __Pyx_PyInt_As_int(values[6]); if (unlikely((__pyx_v_slowd_period == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 4597, __pyx_L3_error)
-    } else {
-      __pyx_v_slowd_period = ((int)-2147483648);
-    }
-    if (values[7]) {
-      __pyx_v_slowd_matype = __Pyx_PyInt_As_int(values[7]); if (unlikely((__pyx_v_slowd_matype == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 4597, __pyx_L3_error)
+    if (values[2]) {
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[2]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4269, __pyx_L3_error)
     } else {
-      __pyx_v_slowd_matype = ((int)0);
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
     }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("STOCH", 0, 3, 8, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 4597, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("PLUS_DM", 0, 2, 3, __pyx_nargs); __PYX_ERR(4, 4267, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.STOCH", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.PLUS_DM", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(2, 4597, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(2, 4597, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(2, 4597, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_296STOCH(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_fastk_period, __pyx_v_slowk_period, __pyx_v_slowk_matype, __pyx_v_slowd_period, __pyx_v_slowd_matype);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 4269, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 4269, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_274PLUS_DM(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_timeperiod);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_296STOCH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_fastk_period, int __pyx_v_slowk_period, int __pyx_v_slowk_matype, int __pyx_v_slowd_period, int __pyx_v_slowd_matype) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_274PLUS_DM(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, int __pyx_v_timeperiod) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -28332,84 +34302,65 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_296STOCH(CYTHON_UNUSED PyObject *__pyx
   TA_RetCode __pyx_v_retCode;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  PyArrayObject *__pyx_v_outslowk = 0;
-  PyArrayObject *__pyx_v_outslowd = 0;
+  PyArrayObject *__pyx_v_outreal = 0;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
   npy_int __pyx_t_3;
-  __Pyx_RefNannySetupContext("STOCH", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("PLUS_DM", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
-  __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4622, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4288, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4623, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4289, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4624, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(2, 4625, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_high, __pyx_v_low); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 4290, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
-  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx3(__pyx_v_length, ((double *)__pyx_v_high->data), ((double *)__pyx_v_low->data), ((double *)__pyx_v_close->data)); if (unlikely(__pyx_t_3 == ((npy_int)-1))) __PYX_ERR(2, 4626, __pyx_L1_error)
+  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx2(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4291, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_3;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_STOCH_Lookback(__pyx_v_fastk_period, __pyx_v_slowk_period, __pyx_v_slowk_matype, __pyx_v_slowd_period, __pyx_v_slowd_matype));
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4629, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_v_outslowk = ((PyArrayObject *)__pyx_t_1);
-  __pyx_t_1 = 0;
+  __pyx_v_lookback = (__pyx_v_begidx + TA_PLUS_DM_Lookback(__pyx_v_timeperiod));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4630, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4294, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_v_outslowd = ((PyArrayObject *)__pyx_t_1);
+  __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_STOCH(0, __pyx_v_endidx, (((double *)__pyx_v_high->data) + __pyx_v_begidx), (((double *)__pyx_v_low->data) + __pyx_v_begidx), (((double *)__pyx_v_close->data) + __pyx_v_begidx), __pyx_v_fastk_period, __pyx_v_slowk_period, __pyx_v_slowk_matype, __pyx_v_slowd_period, __pyx_v_slowd_matype, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_v_outslowk->data) + __pyx_v_lookback), (((double *)__pyx_v_outslowd->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_PLUS_DM(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_STOCH, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4632, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_PLUS_DM, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4296, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4633, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outslowk));
-  __Pyx_GIVEREF(((PyObject *)__pyx_v_outslowk));
-  PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_outslowk));
-  __Pyx_INCREF(((PyObject *)__pyx_v_outslowd));
-  __Pyx_GIVEREF(((PyObject *)__pyx_v_outslowd));
-  PyTuple_SET_ITEM(__pyx_t_1, 1, ((PyObject *)__pyx_v_outslowd));
-  __pyx_r = __pyx_t_1;
-  __pyx_t_1 = 0;
+  __Pyx_INCREF((PyObject *)__pyx_v_outreal);
+  __pyx_r = ((PyObject *)__pyx_v_outreal);
   goto __pyx_L0;
 
 
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.STOCH", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.PLUS_DM", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_outslowk);
-  __Pyx_XDECREF((PyObject *)__pyx_v_outslowd);
+  __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
   __Pyx_XDECREF((PyObject *)__pyx_v_high);
   __Pyx_XDECREF((PyObject *)__pyx_v_low);
-  __Pyx_XDECREF((PyObject *)__pyx_v_close);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -28417,137 +34368,147 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_296STOCH(CYTHON_UNUSED PyObject *__pyx
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_299STOCHF(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_298STOCHF[] = " STOCHF(high, low, close[, fastk_period=?, fastd_period=?, fastd_matype=?])\n\n    Stochastic Fast (Momentum Indicators)\n\n    Inputs:\n        prices: ['high', 'low', 'close']\n    Parameters:\n        fastk_period: 5\n        fastd_period: 3\n        fastd_matype: 0\n    Outputs:\n        fastk\n        fastd\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_299STOCHF = {"STOCHF", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_299STOCHF, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_298STOCHF};
-static PyObject *__pyx_pw_5talib_7_ta_lib_299STOCHF(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_high = 0;
-  PyArrayObject *__pyx_v_low = 0;
-  PyArrayObject *__pyx_v_close = 0;
-  int __pyx_v_fastk_period;
-  int __pyx_v_fastd_period;
-  int __pyx_v_fastd_matype;
+static PyObject *__pyx_pw_5talib_7_ta_lib_277PPO(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_276PPO, "PPO(ndarray real, int fastperiod=-0x80000000, int slowperiod=-0x80000000, int matype=0)\n\nPPO(real[, fastperiod=?, slowperiod=?, matype=?])\n\nPercentage Price Oscillator (Momentum Indicators)\n\nInputs:\n    real: (any ndarray)\nParameters:\n    fastperiod: 12\n    slowperiod: 26\n    matype: 0 (Simple Moving Average)\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_277PPO = {"PPO", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_277PPO, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_276PPO};
+static PyObject *__pyx_pw_5talib_7_ta_lib_277PPO(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_real = 0;
+  int __pyx_v_fastperiod;
+  int __pyx_v_slowperiod;
+  int __pyx_v_matype;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("STOCHF (wrapper)", 0);
+  __Pyx_RefNannySetupContext("PPO (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,&__pyx_n_s_fastk_period,&__pyx_n_s_fastd_period,&__pyx_n_s_fastd_matype,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);
-        CYTHON_FALLTHROUGH;
-        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
-        CYTHON_FALLTHROUGH;
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_fastperiod,&__pyx_mstate_global->__pyx_n_u_slowperiod,&__pyx_mstate_global->__pyx_n_u_matype,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 4299, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 4299, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 4299, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 4299, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4299, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("STOCHF", 0, 3, 6, 1); __PYX_ERR(2, 4637, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("STOCHF", 0, 3, 6, 2); __PYX_ERR(2, 4637, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_fastk_period);
-          if (value) { values[3] = value; kw_args--; }
-        }
-        CYTHON_FALLTHROUGH;
-        case  4:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_fastd_period);
-          if (value) { values[4] = value; kw_args--; }
-        }
-        CYTHON_FALLTHROUGH;
-        case  5:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_fastd_matype);
-          if (value) { values[5] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "STOCHF") < 0)) __PYX_ERR(2, 4637, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "PPO", 0) < (0)) __PYX_ERR(4, 4299, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("PPO", 0, 1, 4, i); __PYX_ERR(4, 4299, __pyx_L3_error) }
       }
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 4299, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 4299, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 4299, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4299, __pyx_L3_error)
         break;
         default: goto __pyx_L5_argtuple_error;
       }
     }
-    __pyx_v_high = ((PyArrayObject *)values[0]);
-    __pyx_v_low = ((PyArrayObject *)values[1]);
-    __pyx_v_close = ((PyArrayObject *)values[2]);
-    if (values[3]) {
-      __pyx_v_fastk_period = __Pyx_PyInt_As_int(values[3]); if (unlikely((__pyx_v_fastk_period == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 4637, __pyx_L3_error)
+    __pyx_v_real = ((PyArrayObject *)values[0]);
+    if (values[1]) {
+      __pyx_v_fastperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_fastperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4301, __pyx_L3_error)
     } else {
-      __pyx_v_fastk_period = ((int)-2147483648);
+      __pyx_v_fastperiod = ((int)((int)-2147483648));
     }
-    if (values[4]) {
-      __pyx_v_fastd_period = __Pyx_PyInt_As_int(values[4]); if (unlikely((__pyx_v_fastd_period == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 4637, __pyx_L3_error)
+    if (values[2]) {
+      __pyx_v_slowperiod = __Pyx_PyLong_As_int(values[2]); if (unlikely((__pyx_v_slowperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4301, __pyx_L3_error)
     } else {
-      __pyx_v_fastd_period = ((int)-2147483648);
+      __pyx_v_slowperiod = ((int)((int)-2147483648));
     }
-    if (values[5]) {
-      __pyx_v_fastd_matype = __Pyx_PyInt_As_int(values[5]); if (unlikely((__pyx_v_fastd_matype == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 4637, __pyx_L3_error)
+    if (values[3]) {
+      __pyx_v_matype = __Pyx_PyLong_As_int(values[3]); if (unlikely((__pyx_v_matype == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4301, __pyx_L3_error)
     } else {
-      __pyx_v_fastd_matype = ((int)0);
+      __pyx_v_matype = ((int)((int)0));
     }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("STOCHF", 0, 3, 6, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 4637, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("PPO", 0, 1, 4, __pyx_nargs); __PYX_ERR(4, 4299, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.STOCHF", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.PPO", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(2, 4637, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(2, 4637, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(2, 4637, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_298STOCHF(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_fastk_period, __pyx_v_fastd_period, __pyx_v_fastd_matype);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 4301, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_276PPO(__pyx_self, __pyx_v_real, __pyx_v_fastperiod, __pyx_v_slowperiod, __pyx_v_matype);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_298STOCHF(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_fastk_period, int __pyx_v_fastd_period, int __pyx_v_fastd_matype) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_276PPO(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_fastperiod, int __pyx_v_slowperiod, int __pyx_v_matype) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -28555,84 +34516,56 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_298STOCHF(CYTHON_UNUSED PyObject *__py
   TA_RetCode __pyx_v_retCode;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  PyArrayObject *__pyx_v_outfastk = 0;
-  PyArrayObject *__pyx_v_outfastd = 0;
+  PyArrayObject *__pyx_v_outreal = 0;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  npy_intp __pyx_t_2;
-  npy_int __pyx_t_3;
-  __Pyx_RefNannySetupContext("STOCHF", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_high);
-  __Pyx_INCREF((PyObject *)__pyx_v_low);
-  __Pyx_INCREF((PyObject *)__pyx_v_close);
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4660, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4661, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
+  npy_int __pyx_t_2;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("PPO", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4662, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4322, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(2, 4663, __pyx_L1_error)
-  __pyx_v_length = __pyx_t_2;
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
-  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx3(__pyx_v_length, ((double *)__pyx_v_high->data), ((double *)__pyx_v_low->data), ((double *)__pyx_v_close->data)); if (unlikely(__pyx_t_3 == ((npy_int)-1))) __PYX_ERR(2, 4664, __pyx_L1_error)
-  __pyx_v_begidx = __pyx_t_3;
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4324, __pyx_L1_error)
+  __pyx_v_begidx = __pyx_t_2;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_STOCHF_Lookback(__pyx_v_fastk_period, __pyx_v_fastd_period, __pyx_v_fastd_matype));
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4667, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_v_outfastk = ((PyArrayObject *)__pyx_t_1);
-  __pyx_t_1 = 0;
+  __pyx_v_lookback = (__pyx_v_begidx + TA_PPO_Lookback(__pyx_v_fastperiod, __pyx_v_slowperiod, __pyx_v_matype));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4668, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4327, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_v_outfastd = ((PyArrayObject *)__pyx_t_1);
+  __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_STOCHF(0, __pyx_v_endidx, (((double *)__pyx_v_high->data) + __pyx_v_begidx), (((double *)__pyx_v_low->data) + __pyx_v_begidx), (((double *)__pyx_v_close->data) + __pyx_v_begidx), __pyx_v_fastk_period, __pyx_v_fastd_period, __pyx_v_fastd_matype, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_v_outfastk->data) + __pyx_v_lookback), (((double *)__pyx_v_outfastd->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_PPO(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), __pyx_v_fastperiod, __pyx_v_slowperiod, __pyx_v_matype, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_STOCHF, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4670, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_PPO, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4329, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4671, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outfastk));
-  __Pyx_GIVEREF(((PyObject *)__pyx_v_outfastk));
-  PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_outfastk));
-  __Pyx_INCREF(((PyObject *)__pyx_v_outfastd));
-  __Pyx_GIVEREF(((PyObject *)__pyx_v_outfastd));
-  PyTuple_SET_ITEM(__pyx_t_1, 1, ((PyObject *)__pyx_v_outfastd));
-  __pyx_r = __pyx_t_1;
-  __pyx_t_1 = 0;
+  __Pyx_INCREF((PyObject *)__pyx_v_outreal);
+  __pyx_r = ((PyObject *)__pyx_v_outreal);
   goto __pyx_L0;
 
 
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.STOCHF", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.PPO", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_outfastk);
-  __Pyx_XDECREF((PyObject *)__pyx_v_outfastd);
-  __Pyx_XDECREF((PyObject *)__pyx_v_high);
-  __Pyx_XDECREF((PyObject *)__pyx_v_low);
-  __Pyx_XDECREF((PyObject *)__pyx_v_close);
+  __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
+  __Pyx_XDECREF((PyObject *)__pyx_v_real);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -28640,129 +34573,119 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_298STOCHF(CYTHON_UNUSED PyObject *__py
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_301STOCHRSI(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_300STOCHRSI[] = " STOCHRSI(real[, timeperiod=?, fastk_period=?, fastd_period=?, fastd_matype=?])\n\n    Stochastic Relative Strength Index (Momentum Indicators)\n\n    Inputs:\n        real: (any ndarray)\n    Parameters:\n        timeperiod: 14\n        fastk_period: 5\n        fastd_period: 3\n        fastd_matype: 0\n    Outputs:\n        fastk\n        fastd\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_301STOCHRSI = {"STOCHRSI", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_301STOCHRSI, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_300STOCHRSI};
-static PyObject *__pyx_pw_5talib_7_ta_lib_301STOCHRSI(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_279ROC(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_278ROC, "ROC(ndarray real, int timeperiod=-0x80000000)\n\nROC(real[, timeperiod=?])\n\nRate of change : ((real/prevPrice)-1)*100 (Momentum Indicators)\n\nInputs:\n    real: (any ndarray)\nParameters:\n    timeperiod: 10\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_279ROC = {"ROC", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_279ROC, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_278ROC};
+static PyObject *__pyx_pw_5talib_7_ta_lib_279ROC(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_real = 0;
   int __pyx_v_timeperiod;
-  int __pyx_v_fastk_period;
-  int __pyx_v_fastd_period;
-  int __pyx_v_fastd_matype;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("STOCHRSI (wrapper)", 0);
+  __Pyx_RefNannySetupContext("ROC (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,&__pyx_n_s_fastk_period,&__pyx_n_s_fastd_period,&__pyx_n_s_fastd_matype,0};
-    PyObject* values[5] = {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  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
-        CYTHON_FALLTHROUGH;
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 4332, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 4332, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4332, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod);
-          if (value) { values[1] = value; kw_args--; }
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_fastk_period);
-          if (value) { values[2] = value; kw_args--; }
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_fastd_period);
-          if (value) { values[3] = value; kw_args--; }
-        }
-        CYTHON_FALLTHROUGH;
-        case  4:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_fastd_matype);
-          if (value) { values[4] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "STOCHRSI") < 0)) __PYX_ERR(2, 4675, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "ROC", 0) < (0)) __PYX_ERR(4, 4332, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("ROC", 0, 1, 2, i); __PYX_ERR(4, 4332, __pyx_L3_error) }
       }
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
-        CYTHON_FALLTHROUGH;
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 4332, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4332, __pyx_L3_error)
         break;
         default: goto __pyx_L5_argtuple_error;
       }
     }
     __pyx_v_real = ((PyArrayObject *)values[0]);
     if (values[1]) {
-      __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 4675, __pyx_L3_error)
-    } else {
-      __pyx_v_timeperiod = ((int)-2147483648);
-    }
-    if (values[2]) {
-      __pyx_v_fastk_period = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_fastk_period == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 4675, __pyx_L3_error)
-    } else {
-      __pyx_v_fastk_period = ((int)-2147483648);
-    }
-    if (values[3]) {
-      __pyx_v_fastd_period = __Pyx_PyInt_As_int(values[3]); if (unlikely((__pyx_v_fastd_period == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 4675, __pyx_L3_error)
-    } else {
-      __pyx_v_fastd_period = ((int)-2147483648);
-    }
-    if (values[4]) {
-      __pyx_v_fastd_matype = __Pyx_PyInt_As_int(values[4]); if (unlikely((__pyx_v_fastd_matype == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 4675, __pyx_L3_error)
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4334, __pyx_L3_error)
     } else {
-      __pyx_v_fastd_matype = ((int)0);
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
     }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("STOCHRSI", 0, 1, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 4675, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("ROC", 0, 1, 2, __pyx_nargs); __PYX_ERR(4, 4332, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.STOCHRSI", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.ROC", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(2, 4675, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_300STOCHRSI(__pyx_self, __pyx_v_real, __pyx_v_timeperiod, __pyx_v_fastk_period, __pyx_v_fastd_period, __pyx_v_fastd_matype);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 4334, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_278ROC(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_300STOCHRSI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod, int __pyx_v_fastk_period, int __pyx_v_fastd_period, int __pyx_v_fastd_matype) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_278ROC(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -28770,67 +34693,55 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_300STOCHRSI(CYTHON_UNUSED PyObject *__
   TA_RetCode __pyx_v_retCode;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  PyArrayObject *__pyx_v_outfastk = 0;
-  PyArrayObject *__pyx_v_outfastd = 0;
+  PyArrayObject *__pyx_v_outreal = 0;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_int __pyx_t_2;
-  __Pyx_RefNannySetupContext("STOCHRSI", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("ROC", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4699, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4353, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_v_real->data)); if (unlikely(__pyx_t_2 == ((npy_int)-1))) __PYX_ERR(2, 4701, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4355, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_2;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_STOCHRSI_Lookback(__pyx_v_timeperiod, __pyx_v_fastk_period, __pyx_v_fastd_period, __pyx_v_fastd_matype));
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4704, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_v_outfastk = ((PyArrayObject *)__pyx_t_1);
-  __pyx_t_1 = 0;
+  __pyx_v_lookback = (__pyx_v_begidx + TA_ROC_Lookback(__pyx_v_timeperiod));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4705, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4358, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_v_outfastd = ((PyArrayObject *)__pyx_t_1);
+  __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_STOCHRSI(0, __pyx_v_endidx, (((double *)__pyx_v_real->data) + __pyx_v_begidx), __pyx_v_timeperiod, __pyx_v_fastk_period, __pyx_v_fastd_period, __pyx_v_fastd_matype, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_v_outfastk->data) + __pyx_v_lookback), (((double *)__pyx_v_outfastd->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_ROC(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_STOCHRSI, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4707, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_ROC, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4360, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4708, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outfastk));
-  __Pyx_GIVEREF(((PyObject *)__pyx_v_outfastk));
-  PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_outfastk));
-  __Pyx_INCREF(((PyObject *)__pyx_v_outfastd));
-  __Pyx_GIVEREF(((PyObject *)__pyx_v_outfastd));
-  PyTuple_SET_ITEM(__pyx_t_1, 1, ((PyObject *)__pyx_v_outfastd));
-  __pyx_r = __pyx_t_1;
-  __pyx_t_1 = 0;
+  __Pyx_INCREF((PyObject *)__pyx_v_outreal);
+  __pyx_r = ((PyObject *)__pyx_v_outreal);
   goto __pyx_L0;
 
 
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.STOCHRSI", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.ROC", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_outfastk);
-  __Pyx_XDECREF((PyObject *)__pyx_v_outfastd);
+  __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
   __Pyx_XDECREF((PyObject *)__pyx_v_real);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
@@ -28839,75 +34750,119 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_300STOCHRSI(CYTHON_UNUSED PyObject *__
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_303SUB(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_302SUB[] = " SUB(real0, real1)\n\n    Vector Arithmetic Substraction (Math Operators)\n\n    Inputs:\n        real0: (any ndarray)\n        real1: (any ndarray)\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_303SUB = {"SUB", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_303SUB, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_302SUB};
-static PyObject *__pyx_pw_5talib_7_ta_lib_303SUB(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_real0 = 0;
-  PyArrayObject *__pyx_v_real1 = 0;
+static PyObject *__pyx_pw_5talib_7_ta_lib_281ROCP(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_280ROCP, "ROCP(ndarray real, int timeperiod=-0x80000000)\n\nROCP(real[, timeperiod=?])\n\nRate of change Percentage: (real-prevPrice)/prevPrice (Momentum Indicators)\n\nInputs:\n    real: (any ndarray)\nParameters:\n    timeperiod: 10\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_281ROCP = {"ROCP", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_281ROCP, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_280ROCP};
+static PyObject *__pyx_pw_5talib_7_ta_lib_281ROCP(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_real = 0;
+  int __pyx_v_timeperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("SUB (wrapper)", 0);
+  __Pyx_RefNannySetupContext("ROCP (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real0,&__pyx_n_s_real1,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);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 4363, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 4363, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4363, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real0)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "ROCP", 0) < (0)) __PYX_ERR(4, 4363, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("ROCP", 0, 1, 2, i); __PYX_ERR(4, 4363, __pyx_L3_error) }
+      }
+    } else {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 4363, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real1)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("SUB", 1, 2, 2, 1); __PYX_ERR(2, 4712, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "SUB") < 0)) __PYX_ERR(2, 4712, __pyx_L3_error)
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4363, __pyx_L3_error)
+        break;
+        default: goto __pyx_L5_argtuple_error;
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
-      goto __pyx_L5_argtuple_error;
+    }
+    __pyx_v_real = ((PyArrayObject *)values[0]);
+    if (values[1]) {
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4365, __pyx_L3_error)
     } else {
-      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
     }
-    __pyx_v_real0 = ((PyArrayObject *)values[0]);
-    __pyx_v_real1 = ((PyArrayObject *)values[1]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("SUB", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 4712, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("ROCP", 0, 1, 2, __pyx_nargs); __PYX_ERR(4, 4363, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.SUB", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.ROCP", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real0), __pyx_ptype_5numpy_ndarray, 0, "real0", 0))) __PYX_ERR(2, 4712, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real1), __pyx_ptype_5numpy_ndarray, 0, "real1", 0))) __PYX_ERR(2, 4712, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_302SUB(__pyx_self, __pyx_v_real0, __pyx_v_real1);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 4365, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_280ROCP(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_302SUB(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real0, PyArrayObject *__pyx_v_real1) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_280ROCP(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -28919,45 +34874,40 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_302SUB(CYTHON_UNUSED PyObject *__pyx_s
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  npy_intp __pyx_t_2;
-  npy_int __pyx_t_3;
-  __Pyx_RefNannySetupContext("SUB", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_real0);
-  __Pyx_INCREF((PyObject *)__pyx_v_real1);
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4730, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_real0, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
+  npy_int __pyx_t_2;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("ROCP", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4731, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4384, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_real1, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_real0, __pyx_v_real1); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(2, 4732, __pyx_L1_error)
-  __pyx_v_length = __pyx_t_2;
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
-  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx2(__pyx_v_length, ((double *)__pyx_v_real0->data), ((double *)__pyx_v_real1->data)); if (unlikely(__pyx_t_3 == ((npy_int)-1))) __PYX_ERR(2, 4733, __pyx_L1_error)
-  __pyx_v_begidx = __pyx_t_3;
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4386, __pyx_L1_error)
+  __pyx_v_begidx = __pyx_t_2;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_SUB_Lookback());
+  __pyx_v_lookback = (__pyx_v_begidx + TA_ROCP_Lookback(__pyx_v_timeperiod));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4736, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4389, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_SUB(0, __pyx_v_endidx, (((double *)__pyx_v_real0->data) + __pyx_v_begidx), (((double *)__pyx_v_real1->data) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_v_outreal->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_ROCP(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_SUB, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4738, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_ROCP, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4391, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outreal));
+  __Pyx_INCREF((PyObject *)__pyx_v_outreal);
   __pyx_r = ((PyObject *)__pyx_v_outreal);
   goto __pyx_L0;
 
@@ -28965,12 +34915,11 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_302SUB(CYTHON_UNUSED PyObject *__pyx_s
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.SUB", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.ROCP", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
-  __Pyx_XDECREF((PyObject *)__pyx_v_real0);
-  __Pyx_XDECREF((PyObject *)__pyx_v_real1);
+  __Pyx_XDECREF((PyObject *)__pyx_v_real);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -28978,81 +34927,119 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_302SUB(CYTHON_UNUSED PyObject *__pyx_s
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_305SUM(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_304SUM[] = " SUM(real[, timeperiod=?])\n\n    Summation (Math Operators)\n\n    Inputs:\n        real: (any ndarray)\n    Parameters:\n        timeperiod: 30\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_305SUM = {"SUM", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_305SUM, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_304SUM};
-static PyObject *__pyx_pw_5talib_7_ta_lib_305SUM(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_283ROCR(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_282ROCR, "ROCR(ndarray real, int timeperiod=-0x80000000)\n\nROCR(real[, timeperiod=?])\n\nRate of change ratio: (real/prevPrice) (Momentum Indicators)\n\nInputs:\n    real: (any ndarray)\nParameters:\n    timeperiod: 10\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_283ROCR = {"ROCR", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_283ROCR, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_282ROCR};
+static PyObject *__pyx_pw_5talib_7_ta_lib_283ROCR(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_real = 0;
   int __pyx_v_timeperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("SUM (wrapper)", 0);
+  __Pyx_RefNannySetupContext("ROCR (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,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);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 4394, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 4394, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4394, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod);
-          if (value) { values[1] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "SUM") < 0)) __PYX_ERR(2, 4743, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "ROCR", 0) < (0)) __PYX_ERR(4, 4394, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("ROCR", 0, 1, 2, i); __PYX_ERR(4, 4394, __pyx_L3_error) }
       }
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 4394, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4394, __pyx_L3_error)
         break;
         default: goto __pyx_L5_argtuple_error;
       }
     }
     __pyx_v_real = ((PyArrayObject *)values[0]);
     if (values[1]) {
-      __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 4743, __pyx_L3_error)
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4396, __pyx_L3_error)
     } else {
-      __pyx_v_timeperiod = ((int)-2147483648);
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
     }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("SUM", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 4743, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("ROCR", 0, 1, 2, __pyx_nargs); __PYX_ERR(4, 4394, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.SUM", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.ROCR", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(2, 4743, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_304SUM(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 4396, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_282ROCR(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_304SUM(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_282ROCR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -29065,36 +35052,39 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_304SUM(CYTHON_UNUSED PyObject *__pyx_s
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_int __pyx_t_2;
-  __Pyx_RefNannySetupContext("SUM", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("ROCR", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4762, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4415, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_v_real->data)); if (unlikely(__pyx_t_2 == ((npy_int)-1))) __PYX_ERR(2, 4764, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4417, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_2;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_SUM_Lookback(__pyx_v_timeperiod));
+  __pyx_v_lookback = (__pyx_v_begidx + TA_ROCR_Lookback(__pyx_v_timeperiod));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4767, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4420, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_SUM(0, __pyx_v_endidx, (((double *)__pyx_v_real->data) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_v_outreal->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_ROCR(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_SUM, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4769, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_ROCR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4422, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outreal));
+  __Pyx_INCREF((PyObject *)__pyx_v_outreal);
   __pyx_r = ((PyObject *)__pyx_v_outreal);
   goto __pyx_L0;
 
@@ -29102,7 +35092,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_304SUM(CYTHON_UNUSED PyObject *__pyx_s
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.SUM", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.ROCR", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
@@ -29114,97 +35104,119 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_304SUM(CYTHON_UNUSED PyObject *__pyx_s
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_307T3(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_306T3[] = " T3(real[, timeperiod=?, vfactor=?])\n\n    Triple Exponential Moving Average (T3) (Overlap Studies)\n\n    Inputs:\n        real: (any ndarray)\n    Parameters:\n        timeperiod: 5\n        vfactor: 0.7\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_307T3 = {"T3", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_307T3, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_306T3};
-static PyObject *__pyx_pw_5talib_7_ta_lib_307T3(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_285ROCR100(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_284ROCR100, "ROCR100(ndarray real, int timeperiod=-0x80000000)\n\nROCR100(real[, timeperiod=?])\n\nRate of change ratio 100 scale: (real/prevPrice)*100 (Momentum Indicators)\n\nInputs:\n    real: (any ndarray)\nParameters:\n    timeperiod: 10\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_285ROCR100 = {"ROCR100", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_285ROCR100, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_284ROCR100};
+static PyObject *__pyx_pw_5talib_7_ta_lib_285ROCR100(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_real = 0;
   int __pyx_v_timeperiod;
-  double __pyx_v_vfactor;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("T3 (wrapper)", 0);
+  __Pyx_RefNannySetupContext("ROCR100 (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,&__pyx_n_s_vfactor,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);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 4425, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 4425, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4425, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod);
-          if (value) { values[1] = value; kw_args--; }
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_vfactor);
-          if (value) { values[2] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "T3") < 0)) __PYX_ERR(2, 4774, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "ROCR100", 0) < (0)) __PYX_ERR(4, 4425, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("ROCR100", 0, 1, 2, i); __PYX_ERR(4, 4425, __pyx_L3_error) }
       }
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 4425, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4425, __pyx_L3_error)
         break;
         default: goto __pyx_L5_argtuple_error;
       }
     }
     __pyx_v_real = ((PyArrayObject *)values[0]);
     if (values[1]) {
-      __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 4774, __pyx_L3_error)
-    } else {
-      __pyx_v_timeperiod = ((int)-2147483648);
-    }
-    if (values[2]) {
-      __pyx_v_vfactor = __pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_vfactor == (double)-1) && PyErr_Occurred())) __PYX_ERR(2, 4774, __pyx_L3_error)
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4427, __pyx_L3_error)
     } else {
-      __pyx_v_vfactor = ((double)-4e37);
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
     }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("T3", 0, 1, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 4774, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("ROCR100", 0, 1, 2, __pyx_nargs); __PYX_ERR(4, 4425, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.T3", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.ROCR100", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(2, 4774, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_306T3(__pyx_self, __pyx_v_real, __pyx_v_timeperiod, __pyx_v_vfactor);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 4427, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_284ROCR100(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_306T3(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod, double __pyx_v_vfactor) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_284ROCR100(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -29217,36 +35229,39 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_306T3(CYTHON_UNUSED PyObject *__pyx_se
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_int __pyx_t_2;
-  __Pyx_RefNannySetupContext("T3", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("ROCR100", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4794, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4446, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_v_real->data)); if (unlikely(__pyx_t_2 == ((npy_int)-1))) __PYX_ERR(2, 4796, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4448, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_2;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_T3_Lookback(__pyx_v_timeperiod, __pyx_v_vfactor));
+  __pyx_v_lookback = (__pyx_v_begidx + TA_ROCR100_Lookback(__pyx_v_timeperiod));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4799, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4451, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_T3(0, __pyx_v_endidx, (((double *)__pyx_v_real->data) + __pyx_v_begidx), __pyx_v_timeperiod, __pyx_v_vfactor, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_v_outreal->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_ROCR100(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_T3, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4801, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_ROCR100, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4453, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outreal));
+  __Pyx_INCREF((PyObject *)__pyx_v_outreal);
   __pyx_r = ((PyObject *)__pyx_v_outreal);
   goto __pyx_L0;
 
@@ -29254,7 +35269,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_306T3(CYTHON_UNUSED PyObject *__pyx_se
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.T3", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.ROCR100", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
@@ -29266,26 +35281,119 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_306T3(CYTHON_UNUSED PyObject *__pyx_se
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_309TAN(PyObject *__pyx_self, PyObject *__pyx_v_real); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_308TAN[] = " TAN(real)\n\n    Vector Trigonometric Tan (Math Transform)\n\n    Inputs:\n        real: (any ndarray)\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_309TAN = {"TAN", (PyCFunction)__pyx_pw_5talib_7_ta_lib_309TAN, METH_O, __pyx_doc_5talib_7_ta_lib_308TAN};
-static PyObject *__pyx_pw_5talib_7_ta_lib_309TAN(PyObject *__pyx_self, PyObject *__pyx_v_real) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_287RSI(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_286RSI, "RSI(ndarray real, int timeperiod=-0x80000000)\n\nRSI(real[, timeperiod=?])\n\nRelative Strength Index (Momentum Indicators)\n\nInputs:\n    real: (any ndarray)\nParameters:\n    timeperiod: 14\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_287RSI = {"RSI", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_287RSI, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_286RSI};
+static PyObject *__pyx_pw_5talib_7_ta_lib_287RSI(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_real = 0;
+  int __pyx_v_timeperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("TAN (wrapper)", 0);
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(2, 4806, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_308TAN(__pyx_self, ((PyArrayObject *)__pyx_v_real));
+  __Pyx_RefNannySetupContext("RSI (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 4456, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 4456, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4456, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "RSI", 0) < (0)) __PYX_ERR(4, 4456, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("RSI", 0, 1, 2, i); __PYX_ERR(4, 4456, __pyx_L3_error) }
+      }
+    } else {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 4456, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4456, __pyx_L3_error)
+        break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+    }
+    __pyx_v_real = ((PyArrayObject *)values[0]);
+    if (values[1]) {
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4458, __pyx_L3_error)
+    } else {
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
+    }
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("RSI", 0, 1, 2, __pyx_nargs); __PYX_ERR(4, 4456, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.RSI", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 4458, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_286RSI(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_308TAN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_286RSI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -29298,36 +35406,39 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_308TAN(CYTHON_UNUSED PyObject *__pyx_s
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_int __pyx_t_2;
-  __Pyx_RefNannySetupContext("TAN", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("RSI", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4823, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4477, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_v_real->data)); if (unlikely(__pyx_t_2 == ((npy_int)-1))) __PYX_ERR(2, 4825, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4479, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_2;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_TAN_Lookback());
+  __pyx_v_lookback = (__pyx_v_begidx + TA_RSI_Lookback(__pyx_v_timeperiod));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4828, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4482, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_TAN(0, __pyx_v_endidx, (((double *)__pyx_v_real->data) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_v_outreal->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_RSI(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_TAN, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4830, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_RSI, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4484, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outreal));
+  __Pyx_INCREF((PyObject *)__pyx_v_outreal);
   __pyx_r = ((PyObject *)__pyx_v_outreal);
   goto __pyx_L0;
 
@@ -29335,7 +35446,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_308TAN(CYTHON_UNUSED PyObject *__pyx_s
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.TAN", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.RSI", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
@@ -29347,26 +35458,142 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_308TAN(CYTHON_UNUSED PyObject *__pyx_s
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_311TANH(PyObject *__pyx_self, PyObject *__pyx_v_real); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_310TANH[] = " TANH(real)\n\n    Vector Trigonometric Tanh (Math Transform)\n\n    Inputs:\n        real: (any ndarray)\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_311TANH = {"TANH", (PyCFunction)__pyx_pw_5talib_7_ta_lib_311TANH, METH_O, __pyx_doc_5talib_7_ta_lib_310TANH};
-static PyObject *__pyx_pw_5talib_7_ta_lib_311TANH(PyObject *__pyx_self, PyObject *__pyx_v_real) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_289SAR(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_288SAR, "SAR(ndarray high, ndarray low, double acceleration=0.02, double maximum=0.2)\n\nSAR(high, low[, acceleration=?, maximum=?])\n\nParabolic SAR (Overlap Studies)\n\nInputs:\n    prices: ['high', 'low']\nParameters:\n    acceleration: 0.02\n    maximum: 0.2\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_289SAR = {"SAR", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_289SAR, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_288SAR};
+static PyObject *__pyx_pw_5talib_7_ta_lib_289SAR(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_high = 0;
+  PyArrayObject *__pyx_v_low = 0;
+  double __pyx_v_acceleration;
+  double __pyx_v_maximum;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("TANH (wrapper)", 0);
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(2, 4835, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_310TANH(__pyx_self, ((PyArrayObject *)__pyx_v_real));
-
+  __Pyx_RefNannySetupContext("SAR (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_acceleration,&__pyx_mstate_global->__pyx_n_u_maximum,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 4487, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 4487, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 4487, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 4487, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4487, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "SAR", 0) < (0)) __PYX_ERR(4, 4487, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("SAR", 0, 2, 4, i); __PYX_ERR(4, 4487, __pyx_L3_error) }
+      }
+    } else {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 4487, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 4487, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 4487, __pyx_L3_error)
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4487, __pyx_L3_error)
+        break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+    }
+    __pyx_v_high = ((PyArrayObject *)values[0]);
+    __pyx_v_low = ((PyArrayObject *)values[1]);
+    if (values[2]) {
+      __pyx_v_acceleration = __Pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_acceleration == (double)-1) && PyErr_Occurred())) __PYX_ERR(4, 4489, __pyx_L3_error)
+    } else {
+      __pyx_v_acceleration = ((double)((double)0.02));
+    }
+    if (values[3]) {
+      __pyx_v_maximum = __Pyx_PyFloat_AsDouble(values[3]); if (unlikely((__pyx_v_maximum == (double)-1) && PyErr_Occurred())) __PYX_ERR(4, 4489, __pyx_L3_error)
+    } else {
+      __pyx_v_maximum = ((double)((double)0.2));
+    }
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("SAR", 0, 2, 4, __pyx_nargs); __PYX_ERR(4, 4487, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.SAR", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 4489, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 4489, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_288SAR(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_acceleration, __pyx_v_maximum);
+
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_310TANH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_288SAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, double __pyx_v_acceleration, double __pyx_v_maximum) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -29378,37 +35605,48 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_310TANH(CYTHON_UNUSED PyObject *__pyx_
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  npy_int __pyx_t_2;
-  __Pyx_RefNannySetupContext("TANH", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_real);
+  npy_intp __pyx_t_2;
+  npy_int __pyx_t_3;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("SAR", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_high);
+  __Pyx_INCREF((PyObject *)__pyx_v_low);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4852, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4509, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
+
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4510, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_high, __pyx_v_low); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 4511, __pyx_L1_error)
+  __pyx_v_length = __pyx_t_2;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_v_real->data)); if (unlikely(__pyx_t_2 == ((npy_int)-1))) __PYX_ERR(2, 4854, __pyx_L1_error)
-  __pyx_v_begidx = __pyx_t_2;
+  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx2(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4512, __pyx_L1_error)
+  __pyx_v_begidx = __pyx_t_3;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_TANH_Lookback());
+  __pyx_v_lookback = (__pyx_v_begidx + TA_SAR_Lookback(__pyx_v_acceleration, __pyx_v_maximum));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4857, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4515, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_TANH(0, __pyx_v_endidx, (((double *)__pyx_v_real->data) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_v_outreal->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_SAR(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), __pyx_v_acceleration, __pyx_v_maximum, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_TANH, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4859, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_SAR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4517, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outreal));
+  __Pyx_INCREF((PyObject *)__pyx_v_outreal);
   __pyx_r = ((PyObject *)__pyx_v_outreal);
   goto __pyx_L0;
 
@@ -29416,11 +35654,12 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_310TANH(CYTHON_UNUSED PyObject *__pyx_
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.TANH", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.SAR", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
-  __Pyx_XDECREF((PyObject *)__pyx_v_real);
+  __Pyx_XDECREF((PyObject *)__pyx_v_high);
+  __Pyx_XDECREF((PyObject *)__pyx_v_low);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -29428,81 +35667,226 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_310TANH(CYTHON_UNUSED PyObject *__pyx_
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_313TEMA(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_312TEMA[] = " TEMA(real[, timeperiod=?])\n\n    Triple Exponential Moving Average (Overlap Studies)\n\n    Inputs:\n        real: (any ndarray)\n    Parameters:\n        timeperiod: 30\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_313TEMA = {"TEMA", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_313TEMA, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_312TEMA};
-static PyObject *__pyx_pw_5talib_7_ta_lib_313TEMA(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_real = 0;
-  int __pyx_v_timeperiod;
+static PyObject *__pyx_pw_5talib_7_ta_lib_291SAREXT(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_290SAREXT, "SAREXT(ndarray high, ndarray low, double startvalue=-4e37, double offsetonreverse=-4e37, double accelerationinitlong=-4e37, double accelerationlong=-4e37, double accelerationmaxlong=-4e37, double accelerationinitshort=-4e37, double accelerationshort=-4e37, double accelerationmaxshort=-4e37)\n\nSAREXT(high, low[, startvalue=?, offsetonreverse=?, accelerationinitlong=?, accelerationlong=?, accelerationmaxlong=?, accelerationinitshort=?, accelerationshort=?, accelerationmaxshort=?])\n\nParabolic SAR - Extended (Overlap Studies)\n\nInputs:\n    prices: ['high', 'low']\nParameters:\n    startvalue: 0.0\n    offsetonreverse: 0.0\n    accelerationinitlong: 0.02\n    accelerationlong: 0.02\n    accelerationmaxlong: 0.2\n    accelerationinitshort: 0.02\n    accelerationshort: 0.02\n    accelerationmaxshort: 0.2\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_291SAREXT = {"SAREXT", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_291SAREXT, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_290SAREXT};
+static PyObject *__pyx_pw_5talib_7_ta_lib_291SAREXT(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_high = 0;
+  PyArrayObject *__pyx_v_low = 0;
+  double __pyx_v_startvalue;
+  double __pyx_v_offsetonreverse;
+  double __pyx_v_accelerationinitlong;
+  double __pyx_v_accelerationlong;
+  double __pyx_v_accelerationmaxlong;
+  double __pyx_v_accelerationinitshort;
+  double __pyx_v_accelerationshort;
+  double __pyx_v_accelerationmaxshort;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[10] = {0,0,0,0,0,0,0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("TEMA (wrapper)", 0);
+  __Pyx_RefNannySetupContext("SAREXT (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,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);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_startvalue,&__pyx_mstate_global->__pyx_n_u_offsetonreverse,&__pyx_mstate_global->__pyx_n_u_accelerationinitlong,&__pyx_mstate_global->__pyx_n_u_accelerationlong,&__pyx_mstate_global->__pyx_n_u_accelerationmaxlong,&__pyx_mstate_global->__pyx_n_u_accelerationinitshort,&__pyx_mstate_global->__pyx_n_u_accelerationshort,&__pyx_mstate_global->__pyx_n_u_accelerationmaxshort,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 4520, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case 10:
+        values[9] = __Pyx_ArgRef_FASTCALL(__pyx_args, 9);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[9])) __PYX_ERR(4, 4520, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  9:
+        values[8] = __Pyx_ArgRef_FASTCALL(__pyx_args, 8);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[8])) __PYX_ERR(4, 4520, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  0: break;
-        default: goto __pyx_L5_argtuple_error;
-      }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
+        case  8:
+        values[7] = __Pyx_ArgRef_FASTCALL(__pyx_args, 7);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[7])) __PYX_ERR(4, 4520, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  7:
+        values[6] = __Pyx_ArgRef_FASTCALL(__pyx_args, 6);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(4, 4520, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  6:
+        values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(4, 4520, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  5:
+        values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(4, 4520, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 4520, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 4520, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 4520, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  1:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod);
-          if (value) { values[1] = value; kw_args--; }
-        }
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4520, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
       }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "TEMA") < 0)) __PYX_ERR(2, 4864, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "SAREXT", 0) < (0)) __PYX_ERR(4, 4520, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("SAREXT", 0, 2, 10, i); __PYX_ERR(4, 4520, __pyx_L3_error) }
       }
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      switch (__pyx_nargs) {
+        case 10:
+        values[9] = __Pyx_ArgRef_FASTCALL(__pyx_args, 9);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[9])) __PYX_ERR(4, 4520, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  9:
+        values[8] = __Pyx_ArgRef_FASTCALL(__pyx_args, 8);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[8])) __PYX_ERR(4, 4520, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  8:
+        values[7] = __Pyx_ArgRef_FASTCALL(__pyx_args, 7);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[7])) __PYX_ERR(4, 4520, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  7:
+        values[6] = __Pyx_ArgRef_FASTCALL(__pyx_args, 6);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(4, 4520, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  6:
+        values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(4, 4520, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  5:
+        values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(4, 4520, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 4520, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 4520, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 4520, __pyx_L3_error)
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4520, __pyx_L3_error)
         break;
         default: goto __pyx_L5_argtuple_error;
       }
     }
-    __pyx_v_real = ((PyArrayObject *)values[0]);
-    if (values[1]) {
-      __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 4864, __pyx_L3_error)
+    __pyx_v_high = ((PyArrayObject *)values[0]);
+    __pyx_v_low = ((PyArrayObject *)values[1]);
+    if (values[2]) {
+      __pyx_v_startvalue = __Pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_startvalue == (double)-1) && PyErr_Occurred())) __PYX_ERR(4, 4522, __pyx_L3_error)
+    } else {
+      __pyx_v_startvalue = ((double)((double)-4e37));
+    }
+    if (values[3]) {
+      __pyx_v_offsetonreverse = __Pyx_PyFloat_AsDouble(values[3]); if (unlikely((__pyx_v_offsetonreverse == (double)-1) && PyErr_Occurred())) __PYX_ERR(4, 4522, __pyx_L3_error)
+    } else {
+      __pyx_v_offsetonreverse = ((double)((double)-4e37));
+    }
+    if (values[4]) {
+      __pyx_v_accelerationinitlong = __Pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_accelerationinitlong == (double)-1) && PyErr_Occurred())) __PYX_ERR(4, 4522, __pyx_L3_error)
+    } else {
+      __pyx_v_accelerationinitlong = ((double)((double)-4e37));
+    }
+    if (values[5]) {
+      __pyx_v_accelerationlong = __Pyx_PyFloat_AsDouble(values[5]); if (unlikely((__pyx_v_accelerationlong == (double)-1) && PyErr_Occurred())) __PYX_ERR(4, 4522, __pyx_L3_error)
+    } else {
+      __pyx_v_accelerationlong = ((double)((double)-4e37));
+    }
+    if (values[6]) {
+      __pyx_v_accelerationmaxlong = __Pyx_PyFloat_AsDouble(values[6]); if (unlikely((__pyx_v_accelerationmaxlong == (double)-1) && PyErr_Occurred())) __PYX_ERR(4, 4522, __pyx_L3_error)
+    } else {
+      __pyx_v_accelerationmaxlong = ((double)((double)-4e37));
+    }
+    if (values[7]) {
+      __pyx_v_accelerationinitshort = __Pyx_PyFloat_AsDouble(values[7]); if (unlikely((__pyx_v_accelerationinitshort == (double)-1) && PyErr_Occurred())) __PYX_ERR(4, 4522, __pyx_L3_error)
+    } else {
+      __pyx_v_accelerationinitshort = ((double)((double)-4e37));
+    }
+    if (values[8]) {
+      __pyx_v_accelerationshort = __Pyx_PyFloat_AsDouble(values[8]); if (unlikely((__pyx_v_accelerationshort == (double)-1) && PyErr_Occurred())) __PYX_ERR(4, 4522, __pyx_L3_error)
     } else {
-      __pyx_v_timeperiod = ((int)-2147483648);
+      __pyx_v_accelerationshort = ((double)((double)-4e37));
+    }
+    if (values[9]) {
+      __pyx_v_accelerationmaxshort = __Pyx_PyFloat_AsDouble(values[9]); if (unlikely((__pyx_v_accelerationmaxshort == (double)-1) && PyErr_Occurred())) __PYX_ERR(4, 4522, __pyx_L3_error)
+    } else {
+      __pyx_v_accelerationmaxshort = ((double)((double)-4e37));
     }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("TEMA", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 4864, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("SAREXT", 0, 2, 10, __pyx_nargs); __PYX_ERR(4, 4520, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.TEMA", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.SAREXT", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(2, 4864, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_312TEMA(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 4522, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 4522, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_290SAREXT(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_startvalue, __pyx_v_offsetonreverse, __pyx_v_accelerationinitlong, __pyx_v_accelerationlong, __pyx_v_accelerationmaxlong, __pyx_v_accelerationinitshort, __pyx_v_accelerationshort, __pyx_v_accelerationmaxshort);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_312TEMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_290SAREXT(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, double __pyx_v_startvalue, double __pyx_v_offsetonreverse, double __pyx_v_accelerationinitlong, double __pyx_v_accelerationlong, double __pyx_v_accelerationmaxlong, double __pyx_v_accelerationinitshort, double __pyx_v_accelerationshort, double __pyx_v_accelerationmaxshort) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -29514,37 +35898,48 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_312TEMA(CYTHON_UNUSED PyObject *__pyx_
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  npy_int __pyx_t_2;
-  __Pyx_RefNannySetupContext("TEMA", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_real);
+  npy_intp __pyx_t_2;
+  npy_int __pyx_t_3;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("SAREXT", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_high);
+  __Pyx_INCREF((PyObject *)__pyx_v_low);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4883, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4548, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4549, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_v_real->data)); if (unlikely(__pyx_t_2 == ((npy_int)-1))) __PYX_ERR(2, 4885, __pyx_L1_error)
-  __pyx_v_begidx = __pyx_t_2;
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_high, __pyx_v_low); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 4550, __pyx_L1_error)
+  __pyx_v_length = __pyx_t_2;
+
+  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx2(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4551, __pyx_L1_error)
+  __pyx_v_begidx = __pyx_t_3;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_TEMA_Lookback(__pyx_v_timeperiod));
+  __pyx_v_lookback = (__pyx_v_begidx + TA_SAREXT_Lookback(__pyx_v_startvalue, __pyx_v_offsetonreverse, __pyx_v_accelerationinitlong, __pyx_v_accelerationlong, __pyx_v_accelerationmaxlong, __pyx_v_accelerationinitshort, __pyx_v_accelerationshort, __pyx_v_accelerationmaxshort));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4888, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4554, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_TEMA(0, __pyx_v_endidx, (((double *)__pyx_v_real->data) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_v_outreal->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_SAREXT(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), __pyx_v_startvalue, __pyx_v_offsetonreverse, __pyx_v_accelerationinitlong, __pyx_v_accelerationlong, __pyx_v_accelerationmaxlong, __pyx_v_accelerationinitshort, __pyx_v_accelerationshort, __pyx_v_accelerationmaxshort, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_TEMA, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4890, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_SAREXT, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4556, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outreal));
+  __Pyx_INCREF((PyObject *)__pyx_v_outreal);
   __pyx_r = ((PyObject *)__pyx_v_outreal);
   goto __pyx_L0;
 
@@ -29552,11 +35947,12 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_312TEMA(CYTHON_UNUSED PyObject *__pyx_
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.TEMA", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.SAREXT", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
-  __Pyx_XDECREF((PyObject *)__pyx_v_real);
+  __Pyx_XDECREF((PyObject *)__pyx_v_high);
+  __Pyx_XDECREF((PyObject *)__pyx_v_low);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -29564,87 +35960,102 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_312TEMA(CYTHON_UNUSED PyObject *__pyx_
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_315TRANGE(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_314TRANGE[] = " TRANGE(high, low, close)\n\n    True Range (Volatility Indicators)\n\n    Inputs:\n        prices: ['high', 'low', 'close']\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_315TRANGE = {"TRANGE", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_315TRANGE, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_314TRANGE};
-static PyObject *__pyx_pw_5talib_7_ta_lib_315TRANGE(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_high = 0;
-  PyArrayObject *__pyx_v_low = 0;
-  PyArrayObject *__pyx_v_close = 0;
+static PyObject *__pyx_pw_5talib_7_ta_lib_293SIN(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_292SIN, "SIN(ndarray real)\n\nSIN(real)\n\nVector Trigonometric Sin (Math Transform)\n\nInputs:\n    real: (any ndarray)\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_293SIN = {"SIN", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_293SIN, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_292SIN};
+static PyObject *__pyx_pw_5talib_7_ta_lib_293SIN(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_real = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("TRANGE (wrapper)", 0);
+  __Pyx_RefNannySetupContext("SIN (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,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);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 4559, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4559, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("TRANGE", 1, 3, 3, 1); __PYX_ERR(2, 4895, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("TRANGE", 1, 3, 3, 2); __PYX_ERR(2, 4895, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "TRANGE") < 0)) __PYX_ERR(2, 4895, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "SIN", 0) < (0)) __PYX_ERR(4, 4559, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("SIN", 1, 1, 1, i); __PYX_ERR(4, 4559, __pyx_L3_error) }
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 3) {
+    } else if (unlikely(__pyx_nargs != 1)) {
       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[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4559, __pyx_L3_error)
     }
-    __pyx_v_high = ((PyArrayObject *)values[0]);
-    __pyx_v_low = ((PyArrayObject *)values[1]);
-    __pyx_v_close = ((PyArrayObject *)values[2]);
+    __pyx_v_real = ((PyArrayObject *)values[0]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("TRANGE", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 4895, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("SIN", 1, 1, 1, __pyx_nargs); __PYX_ERR(4, 4559, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.TRANGE", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.SIN", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(2, 4895, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(2, 4895, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(2, 4895, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_314TRANGE(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 4561, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_292SIN(__pyx_self, __pyx_v_real);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_314TRANGE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_292SIN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -29656,51 +36067,40 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_314TRANGE(CYTHON_UNUSED PyObject *__py
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  npy_intp __pyx_t_2;
-  npy_int __pyx_t_3;
-  __Pyx_RefNannySetupContext("TRANGE", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_high);
-  __Pyx_INCREF((PyObject *)__pyx_v_low);
-  __Pyx_INCREF((PyObject *)__pyx_v_close);
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4912, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4913, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
+  npy_int __pyx_t_2;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("SIN", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4914, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4578, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(2, 4915, __pyx_L1_error)
-  __pyx_v_length = __pyx_t_2;
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
-  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx3(__pyx_v_length, ((double *)__pyx_v_high->data), ((double *)__pyx_v_low->data), ((double *)__pyx_v_close->data)); if (unlikely(__pyx_t_3 == ((npy_int)-1))) __PYX_ERR(2, 4916, __pyx_L1_error)
-  __pyx_v_begidx = __pyx_t_3;
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4580, __pyx_L1_error)
+  __pyx_v_begidx = __pyx_t_2;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_TRANGE_Lookback());
+  __pyx_v_lookback = (__pyx_v_begidx + TA_SIN_Lookback());
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4919, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4583, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_TRANGE(0, __pyx_v_endidx, (((double *)__pyx_v_high->data) + __pyx_v_begidx), (((double *)__pyx_v_low->data) + __pyx_v_begidx), (((double *)__pyx_v_close->data) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_v_outreal->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_SIN(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_TRANGE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4921, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_SIN, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4585, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outreal));
+  __Pyx_INCREF((PyObject *)__pyx_v_outreal);
   __pyx_r = ((PyObject *)__pyx_v_outreal);
   goto __pyx_L0;
 
@@ -29708,13 +36108,11 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_314TRANGE(CYTHON_UNUSED PyObject *__py
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.TRANGE", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.SIN", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
-  __Pyx_XDECREF((PyObject *)__pyx_v_high);
-  __Pyx_XDECREF((PyObject *)__pyx_v_low);
-  __Pyx_XDECREF((PyObject *)__pyx_v_close);
+  __Pyx_XDECREF((PyObject *)__pyx_v_real);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -29722,81 +36120,102 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_314TRANGE(CYTHON_UNUSED PyObject *__py
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_317TRIMA(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_316TRIMA[] = " TRIMA(real[, timeperiod=?])\n\n    Triangular Moving Average (Overlap Studies)\n\n    Inputs:\n        real: (any ndarray)\n    Parameters:\n        timeperiod: 30\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_317TRIMA = {"TRIMA", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_317TRIMA, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_316TRIMA};
-static PyObject *__pyx_pw_5talib_7_ta_lib_317TRIMA(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_295SINH(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_294SINH, "SINH(ndarray real)\n\nSINH(real)\n\nVector Trigonometric Sinh (Math Transform)\n\nInputs:\n    real: (any ndarray)\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_295SINH = {"SINH", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_295SINH, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_294SINH};
+static PyObject *__pyx_pw_5talib_7_ta_lib_295SINH(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_real = 0;
-  int __pyx_v_timeperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("TRIMA (wrapper)", 0);
+  __Pyx_RefNannySetupContext("SINH (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,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);
-        CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 4588, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4588, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod);
-          if (value) { values[1] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "TRIMA") < 0)) __PYX_ERR(2, 4926, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "SINH", 0) < (0)) __PYX_ERR(4, 4588, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("SINH", 1, 1, 1, i); __PYX_ERR(4, 4588, __pyx_L3_error) }
       }
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-        break;
-        default: goto __pyx_L5_argtuple_error;
-      }
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4588, __pyx_L3_error)
     }
     __pyx_v_real = ((PyArrayObject *)values[0]);
-    if (values[1]) {
-      __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 4926, __pyx_L3_error)
-    } else {
-      __pyx_v_timeperiod = ((int)-2147483648);
-    }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("TRIMA", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 4926, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("SINH", 1, 1, 1, __pyx_nargs); __PYX_ERR(4, 4588, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.TRIMA", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.SINH", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(2, 4926, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_316TRIMA(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 4590, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_294SINH(__pyx_self, __pyx_v_real);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_316TRIMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_294SINH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -29809,36 +36228,39 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_316TRIMA(CYTHON_UNUSED PyObject *__pyx
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_int __pyx_t_2;
-  __Pyx_RefNannySetupContext("TRIMA", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("SINH", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4945, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4607, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_v_real->data)); if (unlikely(__pyx_t_2 == ((npy_int)-1))) __PYX_ERR(2, 4947, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4609, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_2;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_TRIMA_Lookback(__pyx_v_timeperiod));
+  __pyx_v_lookback = (__pyx_v_begidx + TA_SINH_Lookback());
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4950, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4612, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_TRIMA(0, __pyx_v_endidx, (((double *)__pyx_v_real->data) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_v_outreal->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_SINH(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_TRIMA, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4952, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_SINH, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4614, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outreal));
+  __Pyx_INCREF((PyObject *)__pyx_v_outreal);
   __pyx_r = ((PyObject *)__pyx_v_outreal);
   goto __pyx_L0;
 
@@ -29846,7 +36268,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_316TRIMA(CYTHON_UNUSED PyObject *__pyx
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.TRIMA", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.SINH", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
@@ -29858,81 +36280,119 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_316TRIMA(CYTHON_UNUSED PyObject *__pyx
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_319TRIX(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_318TRIX[] = " TRIX(real[, timeperiod=?])\n\n    1-day Rate-Of-Change (ROC) of a Triple Smooth EMA (Momentum Indicators)\n\n    Inputs:\n        real: (any ndarray)\n    Parameters:\n        timeperiod: 30\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_319TRIX = {"TRIX", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_319TRIX, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_318TRIX};
-static PyObject *__pyx_pw_5talib_7_ta_lib_319TRIX(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_297SMA(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_296SMA, "SMA(ndarray real, int timeperiod=-0x80000000)\n\nSMA(real[, timeperiod=?])\n\nSimple Moving Average (Overlap Studies)\n\nInputs:\n    real: (any ndarray)\nParameters:\n    timeperiod: 30\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_297SMA = {"SMA", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_297SMA, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_296SMA};
+static PyObject *__pyx_pw_5talib_7_ta_lib_297SMA(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_real = 0;
   int __pyx_v_timeperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("TRIX (wrapper)", 0);
+  __Pyx_RefNannySetupContext("SMA (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,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);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 4617, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 4617, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4617, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod);
-          if (value) { values[1] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "TRIX") < 0)) __PYX_ERR(2, 4957, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "SMA", 0) < (0)) __PYX_ERR(4, 4617, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("SMA", 0, 1, 2, i); __PYX_ERR(4, 4617, __pyx_L3_error) }
       }
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 4617, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4617, __pyx_L3_error)
         break;
         default: goto __pyx_L5_argtuple_error;
       }
     }
     __pyx_v_real = ((PyArrayObject *)values[0]);
     if (values[1]) {
-      __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 4957, __pyx_L3_error)
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4619, __pyx_L3_error)
     } else {
-      __pyx_v_timeperiod = ((int)-2147483648);
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
     }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("TRIX", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 4957, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("SMA", 0, 1, 2, __pyx_nargs); __PYX_ERR(4, 4617, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.TRIX", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.SMA", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(2, 4957, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_318TRIX(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 4619, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_296SMA(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_318TRIX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_296SMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -29945,36 +36405,39 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_318TRIX(CYTHON_UNUSED PyObject *__pyx_
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_int __pyx_t_2;
-  __Pyx_RefNannySetupContext("TRIX", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("SMA", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4976, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4638, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_v_real->data)); if (unlikely(__pyx_t_2 == ((npy_int)-1))) __PYX_ERR(2, 4978, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4640, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_2;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_TRIX_Lookback(__pyx_v_timeperiod));
+  __pyx_v_lookback = (__pyx_v_begidx + TA_SMA_Lookback(__pyx_v_timeperiod));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4981, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4643, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_TRIX(0, __pyx_v_endidx, (((double *)__pyx_v_real->data) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_v_outreal->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_SMA(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_TRIX, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4983, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_SMA, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4645, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outreal));
+  __Pyx_INCREF((PyObject *)__pyx_v_outreal);
   __pyx_r = ((PyObject *)__pyx_v_outreal);
   goto __pyx_L0;
 
@@ -29982,7 +36445,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_318TRIX(CYTHON_UNUSED PyObject *__pyx_
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.TRIX", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.SMA", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
@@ -29994,81 +36457,102 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_318TRIX(CYTHON_UNUSED PyObject *__pyx_
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_321TSF(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_320TSF[] = " TSF(real[, timeperiod=?])\n\n    Time Series Forecast (Statistic Functions)\n\n    Inputs:\n        real: (any ndarray)\n    Parameters:\n        timeperiod: 14\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_321TSF = {"TSF", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_321TSF, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_320TSF};
-static PyObject *__pyx_pw_5talib_7_ta_lib_321TSF(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_299SQRT(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_298SQRT, "SQRT(ndarray real)\n\nSQRT(real)\n\nVector Square Root (Math Transform)\n\nInputs:\n    real: (any ndarray)\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_299SQRT = {"SQRT", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_299SQRT, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_298SQRT};
+static PyObject *__pyx_pw_5talib_7_ta_lib_299SQRT(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_real = 0;
-  int __pyx_v_timeperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("TSF (wrapper)", 0);
+  __Pyx_RefNannySetupContext("SQRT (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,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);
-        CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 4648, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4648, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod);
-          if (value) { values[1] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "TSF") < 0)) __PYX_ERR(2, 4988, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "SQRT", 0) < (0)) __PYX_ERR(4, 4648, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("SQRT", 1, 1, 1, i); __PYX_ERR(4, 4648, __pyx_L3_error) }
       }
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-        break;
-        default: goto __pyx_L5_argtuple_error;
-      }
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4648, __pyx_L3_error)
     }
     __pyx_v_real = ((PyArrayObject *)values[0]);
-    if (values[1]) {
-      __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 4988, __pyx_L3_error)
-    } else {
-      __pyx_v_timeperiod = ((int)-2147483648);
-    }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("TSF", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 4988, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("SQRT", 1, 1, 1, __pyx_nargs); __PYX_ERR(4, 4648, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.TSF", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.SQRT", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(2, 4988, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_320TSF(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 4650, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_298SQRT(__pyx_self, __pyx_v_real);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_320TSF(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_298SQRT(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -30081,36 +36565,39 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_320TSF(CYTHON_UNUSED PyObject *__pyx_s
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_int __pyx_t_2;
-  __Pyx_RefNannySetupContext("TSF", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("SQRT", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 5007, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4667, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_v_real->data)); if (unlikely(__pyx_t_2 == ((npy_int)-1))) __PYX_ERR(2, 5009, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4669, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_2;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_TSF_Lookback(__pyx_v_timeperiod));
+  __pyx_v_lookback = (__pyx_v_begidx + TA_SQRT_Lookback());
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 5012, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4672, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_TSF(0, __pyx_v_endidx, (((double *)__pyx_v_real->data) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_v_outreal->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_SQRT(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_TSF, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 5014, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_SQRT, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4674, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outreal));
+  __Pyx_INCREF((PyObject *)__pyx_v_outreal);
   __pyx_r = ((PyObject *)__pyx_v_outreal);
   goto __pyx_L0;
 
@@ -30118,7 +36605,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_320TSF(CYTHON_UNUSED PyObject *__pyx_s
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.TSF", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.SQRT", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
@@ -30130,87 +36617,133 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_320TSF(CYTHON_UNUSED PyObject *__pyx_s
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_323TYPPRICE(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_322TYPPRICE[] = " TYPPRICE(high, low, close)\n\n    Typical Price (Price Transform)\n\n    Inputs:\n        prices: ['high', 'low', 'close']\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_323TYPPRICE = {"TYPPRICE", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_323TYPPRICE, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_322TYPPRICE};
-static PyObject *__pyx_pw_5talib_7_ta_lib_323TYPPRICE(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_high = 0;
-  PyArrayObject *__pyx_v_low = 0;
-  PyArrayObject *__pyx_v_close = 0;
+static PyObject *__pyx_pw_5talib_7_ta_lib_301STDDEV(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_300STDDEV, "STDDEV(ndarray real, int timeperiod=-0x80000000, double nbdev=-4e37)\n\nSTDDEV(real[, timeperiod=?, nbdev=?])\n\nStandard Deviation (Statistic Functions)\n\nInputs:\n    real: (any ndarray)\nParameters:\n    timeperiod: 5\n    nbdev: 1.0\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_301STDDEV = {"STDDEV", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_301STDDEV, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_300STDDEV};
+static PyObject *__pyx_pw_5talib_7_ta_lib_301STDDEV(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_real = 0;
+  int __pyx_v_timeperiod;
+  double __pyx_v_nbdev;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[3] = {0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("TYPPRICE (wrapper)", 0);
+  __Pyx_RefNannySetupContext("STDDEV (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,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);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,&__pyx_mstate_global->__pyx_n_u_nbdev,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 4677, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 4677, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 4677, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4677, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("TYPPRICE", 1, 3, 3, 1); __PYX_ERR(2, 5019, __pyx_L3_error)
-        }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "STDDEV", 0) < (0)) __PYX_ERR(4, 4677, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("STDDEV", 0, 1, 3, i); __PYX_ERR(4, 4677, __pyx_L3_error) }
+      }
+    } else {
+      switch (__pyx_nargs) {
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 4677, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("TYPPRICE", 1, 3, 3, 2); __PYX_ERR(2, 5019, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "TYPPRICE") < 0)) __PYX_ERR(2, 5019, __pyx_L3_error)
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 4677, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4677, __pyx_L3_error)
+        break;
+        default: goto __pyx_L5_argtuple_error;
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 3) {
-      goto __pyx_L5_argtuple_error;
+    }
+    __pyx_v_real = ((PyArrayObject *)values[0]);
+    if (values[1]) {
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4679, __pyx_L3_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_timeperiod = ((int)((int)-2147483648));
+    }
+    if (values[2]) {
+      __pyx_v_nbdev = __Pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_nbdev == (double)-1) && PyErr_Occurred())) __PYX_ERR(4, 4679, __pyx_L3_error)
+    } else {
+      __pyx_v_nbdev = ((double)((double)-4e37));
     }
-    __pyx_v_high = ((PyArrayObject *)values[0]);
-    __pyx_v_low = ((PyArrayObject *)values[1]);
-    __pyx_v_close = ((PyArrayObject *)values[2]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("TYPPRICE", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 5019, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("STDDEV", 0, 1, 3, __pyx_nargs); __PYX_ERR(4, 4677, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.TYPPRICE", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.STDDEV", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(2, 5019, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(2, 5019, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(2, 5019, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_322TYPPRICE(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 4679, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_300STDDEV(__pyx_self, __pyx_v_real, __pyx_v_timeperiod, __pyx_v_nbdev);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_322TYPPRICE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_300STDDEV(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod, double __pyx_v_nbdev) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -30222,51 +36755,40 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_322TYPPRICE(CYTHON_UNUSED PyObject *__
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  npy_intp __pyx_t_2;
-  npy_int __pyx_t_3;
-  __Pyx_RefNannySetupContext("TYPPRICE", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_high);
-  __Pyx_INCREF((PyObject *)__pyx_v_low);
-  __Pyx_INCREF((PyObject *)__pyx_v_close);
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 5036, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 5037, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
+  npy_int __pyx_t_2;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("STDDEV", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 5038, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4699, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(2, 5039, __pyx_L1_error)
-  __pyx_v_length = __pyx_t_2;
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
-  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx3(__pyx_v_length, ((double *)__pyx_v_high->data), ((double *)__pyx_v_low->data), ((double *)__pyx_v_close->data)); if (unlikely(__pyx_t_3 == ((npy_int)-1))) __PYX_ERR(2, 5040, __pyx_L1_error)
-  __pyx_v_begidx = __pyx_t_3;
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4701, __pyx_L1_error)
+  __pyx_v_begidx = __pyx_t_2;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_TYPPRICE_Lookback());
+  __pyx_v_lookback = (__pyx_v_begidx + TA_STDDEV_Lookback(__pyx_v_timeperiod, __pyx_v_nbdev));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 5043, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4704, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_TYPPRICE(0, __pyx_v_endidx, (((double *)__pyx_v_high->data) + __pyx_v_begidx), (((double *)__pyx_v_low->data) + __pyx_v_begidx), (((double *)__pyx_v_close->data) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_v_outreal->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_STDDEV(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), __pyx_v_timeperiod, __pyx_v_nbdev, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_TYPPRICE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 5045, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_STDDEV, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4706, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outreal));
+  __Pyx_INCREF((PyObject *)__pyx_v_outreal);
   __pyx_r = ((PyObject *)__pyx_v_outreal);
   goto __pyx_L0;
 
@@ -30274,13 +36796,11 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_322TYPPRICE(CYTHON_UNUSED PyObject *__
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.TYPPRICE", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.STDDEV", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
-  __Pyx_XDECREF((PyObject *)__pyx_v_high);
-  __Pyx_XDECREF((PyObject *)__pyx_v_low);
-  __Pyx_XDECREF((PyObject *)__pyx_v_close);
+  __Pyx_XDECREF((PyObject *)__pyx_v_real);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -30288,91 +36808,124 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_322TYPPRICE(CYTHON_UNUSED PyObject *__
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_325ULTOSC(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_324ULTOSC[] = " ULTOSC(high, low, close[, timeperiod1=?, timeperiod2=?, timeperiod3=?])\n\n    Ultimate Oscillator (Momentum Indicators)\n\n    Inputs:\n        prices: ['high', 'low', 'close']\n    Parameters:\n        timeperiod1: 7\n        timeperiod2: 14\n        timeperiod3: 28\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_325ULTOSC = {"ULTOSC", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_325ULTOSC, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_324ULTOSC};
-static PyObject *__pyx_pw_5talib_7_ta_lib_325ULTOSC(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_303STOCH(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_302STOCH, "STOCH(ndarray high, ndarray low, ndarray close, int fastk_period=-0x80000000, int slowk_period=-0x80000000, int slowk_matype=0, int slowd_period=-0x80000000, int slowd_matype=0)\n\nSTOCH(high, low, close[, fastk_period=?, slowk_period=?, slowk_matype=?, slowd_period=?, slowd_matype=?])\n\nStochastic (Momentum Indicators)\n\nInputs:\n    prices: ['high', 'low', 'close']\nParameters:\n    fastk_period: 5\n    slowk_period: 3\n    slowk_matype: 0\n    slowd_period: 3\n    slowd_matype: 0\nOutputs:\n    slowk\n    slowd");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_303STOCH = {"STOCH", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_303STOCH, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_302STOCH};
+static PyObject *__pyx_pw_5talib_7_ta_lib_303STOCH(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
-  int __pyx_v_timeperiod1;
-  int __pyx_v_timeperiod2;
-  int __pyx_v_timeperiod3;
+  int __pyx_v_fastk_period;
+  int __pyx_v_slowk_period;
+  int __pyx_v_slowk_matype;
+  int __pyx_v_slowd_period;
+  int __pyx_v_slowd_matype;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[8] = {0,0,0,0,0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("ULTOSC (wrapper)", 0);
+  __Pyx_RefNannySetupContext("STOCH (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,&__pyx_n_s_timeperiod1,&__pyx_n_s_timeperiod2,&__pyx_n_s_timeperiod3,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);
-        CYTHON_FALLTHROUGH;
-        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
-        CYTHON_FALLTHROUGH;
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,&__pyx_mstate_global->__pyx_n_u_fastk_period,&__pyx_mstate_global->__pyx_n_u_slowk_period,&__pyx_mstate_global->__pyx_n_u_slowk_matype,&__pyx_mstate_global->__pyx_n_u_slowd_period,&__pyx_mstate_global->__pyx_n_u_slowd_matype,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 4709, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  8:
+        values[7] = __Pyx_ArgRef_FASTCALL(__pyx_args, 7);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[7])) __PYX_ERR(4, 4709, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  7:
+        values[6] = __Pyx_ArgRef_FASTCALL(__pyx_args, 6);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(4, 4709, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  6:
+        values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(4, 4709, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  5:
+        values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(4, 4709, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  0: break;
-        default: goto __pyx_L5_argtuple_error;
-      }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 4709, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("ULTOSC", 0, 3, 6, 1); __PYX_ERR(2, 5050, __pyx_L3_error)
-        }
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 4709, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("ULTOSC", 0, 3, 6, 2); __PYX_ERR(2, 5050, __pyx_L3_error)
-        }
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 4709, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod1);
-          if (value) { values[3] = value; kw_args--; }
-        }
-        CYTHON_FALLTHROUGH;
-        case  4:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod2);
-          if (value) { values[4] = value; kw_args--; }
-        }
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4709, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  5:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod3);
-          if (value) { values[5] = value; kw_args--; }
-        }
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
       }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "ULTOSC") < 0)) __PYX_ERR(2, 5050, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "STOCH", 0) < (0)) __PYX_ERR(4, 4709, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 3; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("STOCH", 0, 3, 8, i); __PYX_ERR(4, 4709, __pyx_L3_error) }
       }
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
+      switch (__pyx_nargs) {
+        case  8:
+        values[7] = __Pyx_ArgRef_FASTCALL(__pyx_args, 7);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[7])) __PYX_ERR(4, 4709, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  7:
+        values[6] = __Pyx_ArgRef_FASTCALL(__pyx_args, 6);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(4, 4709, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  6:
+        values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(4, 4709, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
+        case  5:
+        values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(4, 4709, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 4709, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 4709, __pyx_L3_error)
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 4709, __pyx_L3_error)
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4709, __pyx_L3_error)
         break;
         default: goto __pyx_L5_argtuple_error;
       }
@@ -30381,44 +36934,67 @@ static PyObject *__pyx_pw_5talib_7_ta_lib_325ULTOSC(PyObject *__pyx_self, PyObje
     __pyx_v_low = ((PyArrayObject *)values[1]);
     __pyx_v_close = ((PyArrayObject *)values[2]);
     if (values[3]) {
-      __pyx_v_timeperiod1 = __Pyx_PyInt_As_int(values[3]); if (unlikely((__pyx_v_timeperiod1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 5050, __pyx_L3_error)
+      __pyx_v_fastk_period = __Pyx_PyLong_As_int(values[3]); if (unlikely((__pyx_v_fastk_period == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4711, __pyx_L3_error)
     } else {
-      __pyx_v_timeperiod1 = ((int)-2147483648);
+      __pyx_v_fastk_period = ((int)((int)-2147483648));
     }
     if (values[4]) {
-      __pyx_v_timeperiod2 = __Pyx_PyInt_As_int(values[4]); if (unlikely((__pyx_v_timeperiod2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 5050, __pyx_L3_error)
+      __pyx_v_slowk_period = __Pyx_PyLong_As_int(values[4]); if (unlikely((__pyx_v_slowk_period == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4711, __pyx_L3_error)
     } else {
-      __pyx_v_timeperiod2 = ((int)-2147483648);
+      __pyx_v_slowk_period = ((int)((int)-2147483648));
     }
     if (values[5]) {
-      __pyx_v_timeperiod3 = __Pyx_PyInt_As_int(values[5]); if (unlikely((__pyx_v_timeperiod3 == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 5050, __pyx_L3_error)
+      __pyx_v_slowk_matype = __Pyx_PyLong_As_int(values[5]); if (unlikely((__pyx_v_slowk_matype == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4711, __pyx_L3_error)
+    } else {
+      __pyx_v_slowk_matype = ((int)((int)0));
+    }
+    if (values[6]) {
+      __pyx_v_slowd_period = __Pyx_PyLong_As_int(values[6]); if (unlikely((__pyx_v_slowd_period == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4711, __pyx_L3_error)
+    } else {
+      __pyx_v_slowd_period = ((int)((int)-2147483648));
+    }
+    if (values[7]) {
+      __pyx_v_slowd_matype = __Pyx_PyLong_As_int(values[7]); if (unlikely((__pyx_v_slowd_matype == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4711, __pyx_L3_error)
     } else {
-      __pyx_v_timeperiod3 = ((int)-2147483648);
+      __pyx_v_slowd_matype = ((int)((int)0));
     }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("ULTOSC", 0, 3, 6, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 5050, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("STOCH", 0, 3, 8, __pyx_nargs); __PYX_ERR(4, 4709, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.ULTOSC", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.STOCH", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(2, 5050, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(2, 5050, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(2, 5050, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_324ULTOSC(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_timeperiod1, __pyx_v_timeperiod2, __pyx_v_timeperiod3);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 4711, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 4711, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 4711, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_302STOCH(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_fastk_period, __pyx_v_slowk_period, __pyx_v_slowk_matype, __pyx_v_slowd_period, __pyx_v_slowd_matype);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_324ULTOSC(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod1, int __pyx_v_timeperiod2, int __pyx_v_timeperiod3) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_302STOCH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_fastk_period, int __pyx_v_slowk_period, int __pyx_v_slowk_matype, int __pyx_v_slowd_period, int __pyx_v_slowd_matype) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -30426,66 +37002,84 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_324ULTOSC(CYTHON_UNUSED PyObject *__py
   TA_RetCode __pyx_v_retCode;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  PyArrayObject *__pyx_v_outreal = 0;
+  PyArrayObject *__pyx_v_outslowk = 0;
+  PyArrayObject *__pyx_v_outslowd = 0;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
   npy_int __pyx_t_3;
-  __Pyx_RefNannySetupContext("ULTOSC", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("STOCH", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 5071, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4736, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 5072, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4737, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 5073, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4738, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(2, 5074, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 4739, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
-  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx3(__pyx_v_length, ((double *)__pyx_v_high->data), ((double *)__pyx_v_low->data), ((double *)__pyx_v_close->data)); if (unlikely(__pyx_t_3 == ((npy_int)-1))) __PYX_ERR(2, 5075, __pyx_L1_error)
+  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx3(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4740, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_3;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_ULTOSC_Lookback(__pyx_v_timeperiod1, __pyx_v_timeperiod2, __pyx_v_timeperiod3));
+  __pyx_v_lookback = (__pyx_v_begidx + TA_STOCH_Lookback(__pyx_v_fastk_period, __pyx_v_slowk_period, __pyx_v_slowk_matype, __pyx_v_slowd_period, __pyx_v_slowd_matype));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 5078, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4743, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
+  __pyx_v_outslowk = ((PyArrayObject *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4744, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_outslowd = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_ULTOSC(0, __pyx_v_endidx, (((double *)__pyx_v_high->data) + __pyx_v_begidx), (((double *)__pyx_v_low->data) + __pyx_v_begidx), (((double *)__pyx_v_close->data) + __pyx_v_begidx), __pyx_v_timeperiod1, __pyx_v_timeperiod2, __pyx_v_timeperiod3, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_v_outreal->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_STOCH(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), __pyx_v_fastk_period, __pyx_v_slowk_period, __pyx_v_slowk_matype, __pyx_v_slowd_period, __pyx_v_slowd_matype, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outslowk)) + __pyx_v_lookback), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outslowd)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_ULTOSC, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 5080, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_STOCH, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4746, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outreal));
-  __pyx_r = ((PyObject *)__pyx_v_outreal);
+  __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4747, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_INCREF((PyObject *)__pyx_v_outslowk);
+  __Pyx_GIVEREF((PyObject *)__pyx_v_outslowk);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_outslowk)) != (0)) __PYX_ERR(4, 4747, __pyx_L1_error);
+  __Pyx_INCREF((PyObject *)__pyx_v_outslowd);
+  __Pyx_GIVEREF((PyObject *)__pyx_v_outslowd);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, ((PyObject *)__pyx_v_outslowd)) != (0)) __PYX_ERR(4, 4747, __pyx_L1_error);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
   goto __pyx_L0;
 
 
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.ULTOSC", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.STOCH", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
+  __Pyx_XDECREF((PyObject *)__pyx_v_outslowk);
+  __Pyx_XDECREF((PyObject *)__pyx_v_outslowd);
   __Pyx_XDECREF((PyObject *)__pyx_v_high);
   __Pyx_XDECREF((PyObject *)__pyx_v_low);
   __Pyx_XDECREF((PyObject *)__pyx_v_close);
@@ -30496,97 +37090,165 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_324ULTOSC(CYTHON_UNUSED PyObject *__py
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_327VAR(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_326VAR[] = " VAR(real[, timeperiod=?, nbdev=?])\n\n    Variance (Statistic Functions)\n\n    Inputs:\n        real: (any ndarray)\n    Parameters:\n        timeperiod: 5\n        nbdev: 1\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_327VAR = {"VAR", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_327VAR, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_326VAR};
-static PyObject *__pyx_pw_5talib_7_ta_lib_327VAR(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_real = 0;
-  int __pyx_v_timeperiod;
-  double __pyx_v_nbdev;
+static PyObject *__pyx_pw_5talib_7_ta_lib_305STOCHF(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_304STOCHF, "STOCHF(ndarray high, ndarray low, ndarray close, int fastk_period=-0x80000000, int fastd_period=-0x80000000, int fastd_matype=0)\n\nSTOCHF(high, low, close[, fastk_period=?, fastd_period=?, fastd_matype=?])\n\nStochastic Fast (Momentum Indicators)\n\nInputs:\n    prices: ['high', 'low', 'close']\nParameters:\n    fastk_period: 5\n    fastd_period: 3\n    fastd_matype: 0\nOutputs:\n    fastk\n    fastd");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_305STOCHF = {"STOCHF", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_305STOCHF, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_304STOCHF};
+static PyObject *__pyx_pw_5talib_7_ta_lib_305STOCHF(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_high = 0;
+  PyArrayObject *__pyx_v_low = 0;
+  PyArrayObject *__pyx_v_close = 0;
+  int __pyx_v_fastk_period;
+  int __pyx_v_fastd_period;
+  int __pyx_v_fastd_matype;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[6] = {0,0,0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("VAR (wrapper)", 0);
+  __Pyx_RefNannySetupContext("STOCHF (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,&__pyx_n_s_nbdev,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);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,&__pyx_mstate_global->__pyx_n_u_fastk_period,&__pyx_mstate_global->__pyx_n_u_fastd_period,&__pyx_mstate_global->__pyx_n_u_fastd_matype,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 4749, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  6:
+        values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(4, 4749, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  5:
+        values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(4, 4749, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 4749, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  0: break;
-        default: goto __pyx_L5_argtuple_error;
-      }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 4749, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 4749, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  1:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod);
-          if (value) { values[1] = value; kw_args--; }
-        }
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4749, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_nbdev);
-          if (value) { values[2] = value; kw_args--; }
-        }
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
       }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "VAR") < 0)) __PYX_ERR(2, 5085, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "STOCHF", 0) < (0)) __PYX_ERR(4, 4749, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 3; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("STOCHF", 0, 3, 6, i); __PYX_ERR(4, 4749, __pyx_L3_error) }
       }
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+      switch (__pyx_nargs) {
+        case  6:
+        values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(4, 4749, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  5:
+        values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(4, 4749, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 4749, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 4749, __pyx_L3_error)
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 4749, __pyx_L3_error)
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4749, __pyx_L3_error)
         break;
         default: goto __pyx_L5_argtuple_error;
       }
     }
-    __pyx_v_real = ((PyArrayObject *)values[0]);
-    if (values[1]) {
-      __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 5085, __pyx_L3_error)
+    __pyx_v_high = ((PyArrayObject *)values[0]);
+    __pyx_v_low = ((PyArrayObject *)values[1]);
+    __pyx_v_close = ((PyArrayObject *)values[2]);
+    if (values[3]) {
+      __pyx_v_fastk_period = __Pyx_PyLong_As_int(values[3]); if (unlikely((__pyx_v_fastk_period == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4751, __pyx_L3_error)
     } else {
-      __pyx_v_timeperiod = ((int)-2147483648);
+      __pyx_v_fastk_period = ((int)((int)-2147483648));
     }
-    if (values[2]) {
-      __pyx_v_nbdev = __pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_nbdev == (double)-1) && PyErr_Occurred())) __PYX_ERR(2, 5085, __pyx_L3_error)
+    if (values[4]) {
+      __pyx_v_fastd_period = __Pyx_PyLong_As_int(values[4]); if (unlikely((__pyx_v_fastd_period == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4751, __pyx_L3_error)
+    } else {
+      __pyx_v_fastd_period = ((int)((int)-2147483648));
+    }
+    if (values[5]) {
+      __pyx_v_fastd_matype = __Pyx_PyLong_As_int(values[5]); if (unlikely((__pyx_v_fastd_matype == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4751, __pyx_L3_error)
     } else {
-      __pyx_v_nbdev = ((double)-4e37);
+      __pyx_v_fastd_matype = ((int)((int)0));
     }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("VAR", 0, 1, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 5085, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("STOCHF", 0, 3, 6, __pyx_nargs); __PYX_ERR(4, 4749, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.VAR", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.STOCHF", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(2, 5085, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_326VAR(__pyx_self, __pyx_v_real, __pyx_v_timeperiod, __pyx_v_nbdev);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 4751, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 4751, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 4751, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_304STOCHF(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_fastk_period, __pyx_v_fastd_period, __pyx_v_fastd_matype);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_326VAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod, double __pyx_v_nbdev) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_304STOCHF(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_fastk_period, int __pyx_v_fastd_period, int __pyx_v_fastd_matype) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -30594,53 +37256,87 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_326VAR(CYTHON_UNUSED PyObject *__pyx_s
   TA_RetCode __pyx_v_retCode;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  PyArrayObject *__pyx_v_outreal = 0;
+  PyArrayObject *__pyx_v_outfastk = 0;
+  PyArrayObject *__pyx_v_outfastd = 0;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  npy_int __pyx_t_2;
-  __Pyx_RefNannySetupContext("VAR", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_real);
+  npy_intp __pyx_t_2;
+  npy_int __pyx_t_3;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("STOCHF", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_high);
+  __Pyx_INCREF((PyObject *)__pyx_v_low);
+  __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 5105, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4774, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
+
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4775, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
+
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4776, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 4777, __pyx_L1_error)
+  __pyx_v_length = __pyx_t_2;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_v_real->data)); if (unlikely(__pyx_t_2 == ((npy_int)-1))) __PYX_ERR(2, 5107, __pyx_L1_error)
-  __pyx_v_begidx = __pyx_t_2;
+  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx3(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4778, __pyx_L1_error)
+  __pyx_v_begidx = __pyx_t_3;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_VAR_Lookback(__pyx_v_timeperiod, __pyx_v_nbdev));
+  __pyx_v_lookback = (__pyx_v_begidx + TA_STOCHF_Lookback(__pyx_v_fastk_period, __pyx_v_fastd_period, __pyx_v_fastd_matype));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 5110, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4781, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
+  __pyx_v_outfastk = ((PyArrayObject *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4782, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_outfastd = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_VAR(0, __pyx_v_endidx, (((double *)__pyx_v_real->data) + __pyx_v_begidx), __pyx_v_timeperiod, __pyx_v_nbdev, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_v_outreal->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_STOCHF(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), __pyx_v_fastk_period, __pyx_v_fastd_period, __pyx_v_fastd_matype, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outfastk)) + __pyx_v_lookback), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outfastd)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_VAR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 5112, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_STOCHF, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4784, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outreal));
-  __pyx_r = ((PyObject *)__pyx_v_outreal);
+  __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4785, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_INCREF((PyObject *)__pyx_v_outfastk);
+  __Pyx_GIVEREF((PyObject *)__pyx_v_outfastk);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_outfastk)) != (0)) __PYX_ERR(4, 4785, __pyx_L1_error);
+  __Pyx_INCREF((PyObject *)__pyx_v_outfastd);
+  __Pyx_GIVEREF((PyObject *)__pyx_v_outfastd);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, ((PyObject *)__pyx_v_outfastd)) != (0)) __PYX_ERR(4, 4785, __pyx_L1_error);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
   goto __pyx_L0;
 
 
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.VAR", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.STOCHF", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
-  __Pyx_XDECREF((PyObject *)__pyx_v_real);
+  __Pyx_XDECREF((PyObject *)__pyx_v_outfastk);
+  __Pyx_XDECREF((PyObject *)__pyx_v_outfastd);
+  __Pyx_XDECREF((PyObject *)__pyx_v_high);
+  __Pyx_XDECREF((PyObject *)__pyx_v_low);
+  __Pyx_XDECREF((PyObject *)__pyx_v_close);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -30648,87 +37344,161 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_326VAR(CYTHON_UNUSED PyObject *__pyx_s
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_329WCLPRICE(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_328WCLPRICE[] = " WCLPRICE(high, low, close)\n\n    Weighted Close Price (Price Transform)\n\n    Inputs:\n        prices: ['high', 'low', 'close']\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_329WCLPRICE = {"WCLPRICE", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_329WCLPRICE, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_328WCLPRICE};
-static PyObject *__pyx_pw_5talib_7_ta_lib_329WCLPRICE(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_high = 0;
-  PyArrayObject *__pyx_v_low = 0;
-  PyArrayObject *__pyx_v_close = 0;
+static PyObject *__pyx_pw_5talib_7_ta_lib_307STOCHRSI(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_306STOCHRSI, "STOCHRSI(ndarray real, int timeperiod=-0x80000000, int fastk_period=-0x80000000, int fastd_period=-0x80000000, int fastd_matype=0)\n\nSTOCHRSI(real[, timeperiod=?, fastk_period=?, fastd_period=?, fastd_matype=?])\n\nStochastic Relative Strength Index (Momentum Indicators)\n\nInputs:\n    real: (any ndarray)\nParameters:\n    timeperiod: 14\n    fastk_period: 5\n    fastd_period: 3\n    fastd_matype: 0\nOutputs:\n    fastk\n    fastd");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_307STOCHRSI = {"STOCHRSI", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_307STOCHRSI, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_306STOCHRSI};
+static PyObject *__pyx_pw_5talib_7_ta_lib_307STOCHRSI(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_real = 0;
+  int __pyx_v_timeperiod;
+  int __pyx_v_fastk_period;
+  int __pyx_v_fastd_period;
+  int __pyx_v_fastd_matype;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[5] = {0,0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("WCLPRICE (wrapper)", 0);
+  __Pyx_RefNannySetupContext("STOCHRSI (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,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);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,&__pyx_mstate_global->__pyx_n_u_fastk_period,&__pyx_mstate_global->__pyx_n_u_fastd_period,&__pyx_mstate_global->__pyx_n_u_fastd_matype,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 4787, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  5:
+        values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(4, 4787, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 4787, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 4787, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 4787, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4787, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "STOCHRSI", 0) < (0)) __PYX_ERR(4, 4787, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("STOCHRSI", 0, 1, 5, i); __PYX_ERR(4, 4787, __pyx_L3_error) }
+      }
+    } else {
+      switch (__pyx_nargs) {
+        case  5:
+        values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(4, 4787, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("WCLPRICE", 1, 3, 3, 1); __PYX_ERR(2, 5117, __pyx_L3_error)
-        }
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 4787, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 4787, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("WCLPRICE", 1, 3, 3, 2); __PYX_ERR(2, 5117, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "WCLPRICE") < 0)) __PYX_ERR(2, 5117, __pyx_L3_error)
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 4787, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4787, __pyx_L3_error)
+        break;
+        default: goto __pyx_L5_argtuple_error;
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 3) {
-      goto __pyx_L5_argtuple_error;
+    }
+    __pyx_v_real = ((PyArrayObject *)values[0]);
+    if (values[1]) {
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4789, __pyx_L3_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_timeperiod = ((int)((int)-2147483648));
+    }
+    if (values[2]) {
+      __pyx_v_fastk_period = __Pyx_PyLong_As_int(values[2]); if (unlikely((__pyx_v_fastk_period == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4789, __pyx_L3_error)
+    } else {
+      __pyx_v_fastk_period = ((int)((int)-2147483648));
+    }
+    if (values[3]) {
+      __pyx_v_fastd_period = __Pyx_PyLong_As_int(values[3]); if (unlikely((__pyx_v_fastd_period == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4789, __pyx_L3_error)
+    } else {
+      __pyx_v_fastd_period = ((int)((int)-2147483648));
+    }
+    if (values[4]) {
+      __pyx_v_fastd_matype = __Pyx_PyLong_As_int(values[4]); if (unlikely((__pyx_v_fastd_matype == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4789, __pyx_L3_error)
+    } else {
+      __pyx_v_fastd_matype = ((int)((int)0));
     }
-    __pyx_v_high = ((PyArrayObject *)values[0]);
-    __pyx_v_low = ((PyArrayObject *)values[1]);
-    __pyx_v_close = ((PyArrayObject *)values[2]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("WCLPRICE", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 5117, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("STOCHRSI", 0, 1, 5, __pyx_nargs); __PYX_ERR(4, 4787, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.WCLPRICE", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.STOCHRSI", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(2, 5117, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(2, 5117, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(2, 5117, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_328WCLPRICE(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 4789, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_306STOCHRSI(__pyx_self, __pyx_v_real, __pyx_v_timeperiod, __pyx_v_fastk_period, __pyx_v_fastd_period, __pyx_v_fastd_matype);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_328WCLPRICE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_306STOCHRSI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod, int __pyx_v_fastk_period, int __pyx_v_fastd_period, int __pyx_v_fastd_matype) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -30736,69 +37506,71 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_328WCLPRICE(CYTHON_UNUSED PyObject *__
   TA_RetCode __pyx_v_retCode;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  PyArrayObject *__pyx_v_outreal = 0;
+  PyArrayObject *__pyx_v_outfastk = 0;
+  PyArrayObject *__pyx_v_outfastd = 0;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  npy_intp __pyx_t_2;
-  npy_int __pyx_t_3;
-  __Pyx_RefNannySetupContext("WCLPRICE", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_high);
-  __Pyx_INCREF((PyObject *)__pyx_v_low);
-  __Pyx_INCREF((PyObject *)__pyx_v_close);
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 5134, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 5135, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
+  npy_int __pyx_t_2;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("STOCHRSI", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 5136, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4813, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(2, 5137, __pyx_L1_error)
-  __pyx_v_length = __pyx_t_2;
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
-  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx3(__pyx_v_length, ((double *)__pyx_v_high->data), ((double *)__pyx_v_low->data), ((double *)__pyx_v_close->data)); if (unlikely(__pyx_t_3 == ((npy_int)-1))) __PYX_ERR(2, 5138, __pyx_L1_error)
-  __pyx_v_begidx = __pyx_t_3;
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4815, __pyx_L1_error)
+  __pyx_v_begidx = __pyx_t_2;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_WCLPRICE_Lookback());
+  __pyx_v_lookback = (__pyx_v_begidx + TA_STOCHRSI_Lookback(__pyx_v_timeperiod, __pyx_v_fastk_period, __pyx_v_fastd_period, __pyx_v_fastd_matype));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 5141, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4818, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
+  __pyx_v_outfastk = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_WCLPRICE(0, __pyx_v_endidx, (((double *)__pyx_v_high->data) + __pyx_v_begidx), (((double *)__pyx_v_low->data) + __pyx_v_begidx), (((double *)__pyx_v_close->data) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_v_outreal->data) + __pyx_v_lookback));
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4819, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_outfastd = ((PyArrayObject *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  __pyx_v_retCode = TA_STOCHRSI(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), __pyx_v_timeperiod, __pyx_v_fastk_period, __pyx_v_fastd_period, __pyx_v_fastd_matype, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outfastk)) + __pyx_v_lookback), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outfastd)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_WCLPRICE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 5143, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_STOCHRSI, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4821, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outreal));
-  __pyx_r = ((PyObject *)__pyx_v_outreal);
+  __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4822, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_INCREF((PyObject *)__pyx_v_outfastk);
+  __Pyx_GIVEREF((PyObject *)__pyx_v_outfastk);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_outfastk)) != (0)) __PYX_ERR(4, 4822, __pyx_L1_error);
+  __Pyx_INCREF((PyObject *)__pyx_v_outfastd);
+  __Pyx_GIVEREF((PyObject *)__pyx_v_outfastd);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, ((PyObject *)__pyx_v_outfastd)) != (0)) __PYX_ERR(4, 4822, __pyx_L1_error);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
   goto __pyx_L0;
 
 
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.WCLPRICE", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.STOCHRSI", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
-  __Pyx_XDECREF((PyObject *)__pyx_v_high);
-  __Pyx_XDECREF((PyObject *)__pyx_v_low);
-  __Pyx_XDECREF((PyObject *)__pyx_v_close);
+  __Pyx_XDECREF((PyObject *)__pyx_v_outfastk);
+  __Pyx_XDECREF((PyObject *)__pyx_v_outfastd);
+  __Pyx_XDECREF((PyObject *)__pyx_v_real);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -30806,105 +37578,111 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_328WCLPRICE(CYTHON_UNUSED PyObject *__
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_331WILLR(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_330WILLR[] = " WILLR(high, low, close[, timeperiod=?])\n\n    Williams' %R (Momentum Indicators)\n\n    Inputs:\n        prices: ['high', 'low', 'close']\n    Parameters:\n        timeperiod: 14\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_331WILLR = {"WILLR", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_331WILLR, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_330WILLR};
-static PyObject *__pyx_pw_5talib_7_ta_lib_331WILLR(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_high = 0;
-  PyArrayObject *__pyx_v_low = 0;
-  PyArrayObject *__pyx_v_close = 0;
-  int __pyx_v_timeperiod;
+static PyObject *__pyx_pw_5talib_7_ta_lib_309SUB(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_308SUB, "SUB(ndarray real0, ndarray real1)\n\nSUB(real0, real1)\n\nVector Arithmetic Subtraction (Math Operators)\n\nInputs:\n    real0: (any ndarray)\n    real1: (any ndarray)\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_309SUB = {"SUB", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_309SUB, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_308SUB};
+static PyObject *__pyx_pw_5talib_7_ta_lib_309SUB(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_real0 = 0;
+  PyArrayObject *__pyx_v_real1 = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("WILLR (wrapper)", 0);
+  __Pyx_RefNannySetupContext("SUB (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,&__pyx_n_s_timeperiod,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real0,&__pyx_mstate_global->__pyx_n_u_real1,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 4824, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 4824, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4824, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("WILLR", 0, 3, 4, 1); __PYX_ERR(2, 5148, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("WILLR", 0, 3, 4, 2); __PYX_ERR(2, 5148, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod);
-          if (value) { values[3] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "WILLR") < 0)) __PYX_ERR(2, 5148, __pyx_L3_error)
-      }
-    } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-        break;
-        default: goto __pyx_L5_argtuple_error;
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "SUB", 0) < (0)) __PYX_ERR(4, 4824, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("SUB", 1, 2, 2, i); __PYX_ERR(4, 4824, __pyx_L3_error) }
       }
-    }
-    __pyx_v_high = ((PyArrayObject *)values[0]);
-    __pyx_v_low = ((PyArrayObject *)values[1]);
-    __pyx_v_close = ((PyArrayObject *)values[2]);
-    if (values[3]) {
-      __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[3]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 5148, __pyx_L3_error)
+    } else if (unlikely(__pyx_nargs != 2)) {
+      goto __pyx_L5_argtuple_error;
     } else {
-      __pyx_v_timeperiod = ((int)-2147483648);
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4824, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 4824, __pyx_L3_error)
     }
+    __pyx_v_real0 = ((PyArrayObject *)values[0]);
+    __pyx_v_real1 = ((PyArrayObject *)values[1]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("WILLR", 0, 3, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 5148, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("SUB", 1, 2, 2, __pyx_nargs); __PYX_ERR(4, 4824, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.WILLR", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.SUB", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(2, 5148, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(2, 5148, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(2, 5148, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_330WILLR(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_timeperiod);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real0), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real0", 0))) __PYX_ERR(4, 4826, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real1), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real1", 0))) __PYX_ERR(4, 4826, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_308SUB(__pyx_self, __pyx_v_real0, __pyx_v_real1);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_330WILLR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_308SUB(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real0, PyArrayObject *__pyx_v_real1) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -30918,49 +37696,46 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_330WILLR(CYTHON_UNUSED PyObject *__pyx
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
   npy_int __pyx_t_3;
-  __Pyx_RefNannySetupContext("WILLR", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_high);
-  __Pyx_INCREF((PyObject *)__pyx_v_low);
-  __Pyx_INCREF((PyObject *)__pyx_v_close);
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 5167, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("SUB", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_real0);
+  __Pyx_INCREF((PyObject *)__pyx_v_real1);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 5168, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4844, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_real0, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 5169, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4845, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_real1, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(2, 5170, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_real0, __pyx_v_real1); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 4846, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
-  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx3(__pyx_v_length, ((double *)__pyx_v_high->data), ((double *)__pyx_v_low->data), ((double *)__pyx_v_close->data)); if (unlikely(__pyx_t_3 == ((npy_int)-1))) __PYX_ERR(2, 5171, __pyx_L1_error)
+  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx2(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real0)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real1))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4847, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_3;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_WILLR_Lookback(__pyx_v_timeperiod));
+  __pyx_v_lookback = (__pyx_v_begidx + TA_SUB_Lookback());
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 5174, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4850, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_WILLR(0, __pyx_v_endidx, (((double *)__pyx_v_high->data) + __pyx_v_begidx), (((double *)__pyx_v_low->data) + __pyx_v_begidx), (((double *)__pyx_v_close->data) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_v_outreal->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_SUB(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real0)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real1)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_WILLR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 5176, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_SUB, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4852, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outreal));
+  __Pyx_INCREF((PyObject *)__pyx_v_outreal);
   __pyx_r = ((PyObject *)__pyx_v_outreal);
   goto __pyx_L0;
 
@@ -30968,13 +37743,12 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_330WILLR(CYTHON_UNUSED PyObject *__pyx
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.WILLR", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.SUB", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
-  __Pyx_XDECREF((PyObject *)__pyx_v_high);
-  __Pyx_XDECREF((PyObject *)__pyx_v_low);
-  __Pyx_XDECREF((PyObject *)__pyx_v_close);
+  __Pyx_XDECREF((PyObject *)__pyx_v_real0);
+  __Pyx_XDECREF((PyObject *)__pyx_v_real1);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -30982,81 +37756,119 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_330WILLR(CYTHON_UNUSED PyObject *__pyx
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_333WMA(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_332WMA[] = " WMA(real[, timeperiod=?])\n\n    Weighted Moving Average (Overlap Studies)\n\n    Inputs:\n        real: (any ndarray)\n    Parameters:\n        timeperiod: 30\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_333WMA = {"WMA", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_333WMA, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_332WMA};
-static PyObject *__pyx_pw_5talib_7_ta_lib_333WMA(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_311SUM(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_310SUM, "SUM(ndarray real, int timeperiod=-0x80000000)\n\nSUM(real[, timeperiod=?])\n\nSummation (Math Operators)\n\nInputs:\n    real: (any ndarray)\nParameters:\n    timeperiod: 30\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_311SUM = {"SUM", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_311SUM, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_310SUM};
+static PyObject *__pyx_pw_5talib_7_ta_lib_311SUM(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_real = 0;
   int __pyx_v_timeperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("WMA (wrapper)", 0);
+  __Pyx_RefNannySetupContext("SUM (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,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);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 4855, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 4855, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4855, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod);
-          if (value) { values[1] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "WMA") < 0)) __PYX_ERR(2, 5181, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "SUM", 0) < (0)) __PYX_ERR(4, 4855, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("SUM", 0, 1, 2, i); __PYX_ERR(4, 4855, __pyx_L3_error) }
       }
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 4855, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4855, __pyx_L3_error)
         break;
         default: goto __pyx_L5_argtuple_error;
       }
     }
     __pyx_v_real = ((PyArrayObject *)values[0]);
     if (values[1]) {
-      __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 5181, __pyx_L3_error)
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4857, __pyx_L3_error)
     } else {
-      __pyx_v_timeperiod = ((int)-2147483648);
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
     }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("WMA", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 5181, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("SUM", 0, 1, 2, __pyx_nargs); __PYX_ERR(4, 4855, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.WMA", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.SUM", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(2, 5181, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_332WMA(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 4857, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_310SUM(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_332WMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_310SUM(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
   npy_intp __pyx_v_length;
   int __pyx_v_begidx;
   int __pyx_v_endidx;
@@ -31069,36 +37881,39 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_332WMA(CYTHON_UNUSED PyObject *__pyx_s
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_int __pyx_t_2;
-  __Pyx_RefNannySetupContext("WMA", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("SUM", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 5200, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4876, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_v_real->data)); if (unlikely(__pyx_t_2 == ((npy_int)-1))) __PYX_ERR(2, 5202, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4878, __pyx_L1_error)
   __pyx_v_begidx = __pyx_t_2;
 
   __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __pyx_v_lookback = (__pyx_v_begidx + TA_WMA_Lookback(__pyx_v_timeperiod));
+  __pyx_v_lookback = (__pyx_v_begidx + TA_SUM_Lookback(__pyx_v_timeperiod));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 5205, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4881, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_WMA(0, __pyx_v_endidx, (((double *)__pyx_v_real->data) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_v_outreal->data) + __pyx_v_lookback));
+  __pyx_v_retCode = TA_SUM(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_WMA, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 5207, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_SUM, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4883, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_outreal));
+  __Pyx_INCREF((PyObject *)__pyx_v_outreal);
   __pyx_r = ((PyObject *)__pyx_v_outreal);
   goto __pyx_L0;
 
@@ -31106,7 +37921,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_332WMA(CYTHON_UNUSED PyObject *__pyx_s
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.WMA", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.SUM", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
@@ -31118,50 +37933,190 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_332WMA(CYTHON_UNUSED PyObject *__pyx_s
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_335str2bytes(PyObject *__pyx_self, PyObject *__pyx_v_s); /*proto*/
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_335str2bytes = {"str2bytes", (PyCFunction)__pyx_pw_5talib_7_ta_lib_335str2bytes, METH_O, 0};
-static PyObject *__pyx_pw_5talib_7_ta_lib_335str2bytes(PyObject *__pyx_self, PyObject *__pyx_v_s) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_313T3(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_312T3, "T3(ndarray real, int timeperiod=-0x80000000, double vfactor=-4e37)\n\nT3(real[, timeperiod=?, vfactor=?])\n\nTriple Exponential Moving Average (T3) (Overlap Studies)\n\nInputs:\n    real: (any ndarray)\nParameters:\n    timeperiod: 5\n    vfactor: 0.7\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_313T3 = {"T3", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_313T3, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_312T3};
+static PyObject *__pyx_pw_5talib_7_ta_lib_313T3(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_real = 0;
+  int __pyx_v_timeperiod;
+  double __pyx_v_vfactor;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[3] = {0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("str2bytes (wrapper)", 0);
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_334str2bytes(__pyx_self, ((PyObject *)__pyx_v_s));
+  __Pyx_RefNannySetupContext("T3 (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,&__pyx_mstate_global->__pyx_n_u_vfactor,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 4886, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 4886, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 4886, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4886, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "T3", 0) < (0)) __PYX_ERR(4, 4886, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("T3", 0, 1, 3, i); __PYX_ERR(4, 4886, __pyx_L3_error) }
+      }
+    } else {
+      switch (__pyx_nargs) {
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 4886, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 4886, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4886, __pyx_L3_error)
+        break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+    }
+    __pyx_v_real = ((PyArrayObject *)values[0]);
+    if (values[1]) {
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4888, __pyx_L3_error)
+    } else {
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
+    }
+    if (values[2]) {
+      __pyx_v_vfactor = __Pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_vfactor == (double)-1) && PyErr_Occurred())) __PYX_ERR(4, 4888, __pyx_L3_error)
+    } else {
+      __pyx_v_vfactor = ((double)((double)-4e37));
+    }
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("T3", 0, 1, 3, __pyx_nargs); __PYX_ERR(4, 4886, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.T3", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 4888, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_312T3(__pyx_self, __pyx_v_real, __pyx_v_timeperiod, __pyx_v_vfactor);
 
   /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
+  __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_334str2bytes(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_s) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_312T3(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod, double __pyx_v_vfactor) {
+  npy_intp __pyx_v_length;
+  int __pyx_v_begidx;
+  int __pyx_v_endidx;
+  int __pyx_v_lookback;
+  TA_RetCode __pyx_v_retCode;
+  int __pyx_v_outbegidx;
+  int __pyx_v_outnbelement;
+  PyArrayObject *__pyx_v_outreal = 0;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  PyObject *__pyx_t_2 = NULL;
-  __Pyx_RefNannySetupContext("str2bytes", 0);
+  npy_int __pyx_t_2;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("T3", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 48, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4908, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
+
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
+
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4910, __pyx_L1_error)
+  __pyx_v_begidx = __pyx_t_2;
+
+  __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
+
+  __pyx_v_lookback = (__pyx_v_begidx + TA_T3_Lookback(__pyx_v_timeperiod, __pyx_v_vfactor));
+
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4913, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  __pyx_v_retCode = TA_T3(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), __pyx_v_timeperiod, __pyx_v_vfactor, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback));
+
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_T3, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4915, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_INCREF(__pyx_v_s);
-  __Pyx_GIVEREF(__pyx_v_s);
-  PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_s);
-  __Pyx_INCREF(__pyx_n_s_ascii);
-  __Pyx_GIVEREF(__pyx_n_s_ascii);
-  PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_n_s_ascii);
-  __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)(&PyBytes_Type)), __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 48, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_r = __pyx_t_2;
-  __pyx_t_2 = 0;
+
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF((PyObject *)__pyx_v_outreal);
+  __pyx_r = ((PyObject *)__pyx_v_outreal);
   goto __pyx_L0;
 
 
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_XDECREF(__pyx_t_2);
-  __Pyx_AddTraceback("talib._ta_lib.str2bytes", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.T3", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
+  __Pyx_XDECREF((PyObject *)__pyx_v_real);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -31169,58 +38124,159 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_334str2bytes(CYTHON_UNUSED PyObject *_
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_337bytes2str(PyObject *__pyx_self, PyObject *__pyx_v_b); /*proto*/
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_337bytes2str = {"bytes2str", (PyCFunction)__pyx_pw_5talib_7_ta_lib_337bytes2str, METH_O, 0};
-static PyObject *__pyx_pw_5talib_7_ta_lib_337bytes2str(PyObject *__pyx_self, PyObject *__pyx_v_b) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_315TAN(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_314TAN, "TAN(ndarray real)\n\nTAN(real)\n\nVector Trigonometric Tan (Math Transform)\n\nInputs:\n    real: (any ndarray)\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_315TAN = {"TAN", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_315TAN, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_314TAN};
+static PyObject *__pyx_pw_5talib_7_ta_lib_315TAN(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_real = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("bytes2str (wrapper)", 0);
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_336bytes2str(__pyx_self, ((PyObject *)__pyx_v_b));
+  __Pyx_RefNannySetupContext("TAN (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 4918, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4918, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "TAN", 0) < (0)) __PYX_ERR(4, 4918, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("TAN", 1, 1, 1, i); __PYX_ERR(4, 4918, __pyx_L3_error) }
+      }
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4918, __pyx_L3_error)
+    }
+    __pyx_v_real = ((PyArrayObject *)values[0]);
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("TAN", 1, 1, 1, __pyx_nargs); __PYX_ERR(4, 4918, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.TAN", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 4920, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_314TAN(__pyx_self, __pyx_v_real);
 
   /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
+  __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_336bytes2str(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_b) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_314TAN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) {
+  npy_intp __pyx_v_length;
+  int __pyx_v_begidx;
+  int __pyx_v_endidx;
+  int __pyx_v_lookback;
+  TA_RetCode __pyx_v_retCode;
+  int __pyx_v_outbegidx;
+  int __pyx_v_outnbelement;
+  PyArrayObject *__pyx_v_outreal = 0;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  PyObject *__pyx_t_2 = NULL;
-  PyObject *__pyx_t_3 = NULL;
-  __Pyx_RefNannySetupContext("bytes2str", 0);
+  npy_int __pyx_t_2;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("TAN", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __Pyx_XDECREF(__pyx_r);
-  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_b, __pyx_n_s_decode); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 51, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = NULL;
-  if (CYTHON_UNPACK_METHODS && likely(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);
-    }
-  }
-  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_n_s_ascii) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_n_s_ascii);
-  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
-  if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 51, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4937, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __pyx_r = __pyx_t_1;
+  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
+
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
+
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4939, __pyx_L1_error)
+  __pyx_v_begidx = __pyx_t_2;
+
+  __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
+
+  __pyx_v_lookback = (__pyx_v_begidx + TA_TAN_Lookback());
+
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4942, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
+
+  __pyx_v_retCode = TA_TAN(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback));
+
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_TAN, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4944, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF((PyObject *)__pyx_v_outreal);
+  __pyx_r = ((PyObject *)__pyx_v_outreal);
   goto __pyx_L0;
 
 
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_XDECREF(__pyx_t_2);
-  __Pyx_XDECREF(__pyx_t_3);
-  __Pyx_AddTraceback("talib._ta_lib.bytes2str", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.TAN", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
+  __Pyx_XDECREF((PyObject *)__pyx_v_real);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -31228,32 +38284,159 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_336bytes2str(CYTHON_UNUSED PyObject *_
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_339str2bytes(PyObject *__pyx_self, PyObject *__pyx_v_s); /*proto*/
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_339str2bytes = {"str2bytes", (PyCFunction)__pyx_pw_5talib_7_ta_lib_339str2bytes, METH_O, 0};
-static PyObject *__pyx_pw_5talib_7_ta_lib_339str2bytes(PyObject *__pyx_self, PyObject *__pyx_v_s) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_317TANH(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_316TANH, "TANH(ndarray real)\n\nTANH(real)\n\nVector Trigonometric Tanh (Math Transform)\n\nInputs:\n    real: (any ndarray)\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_317TANH = {"TANH", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_317TANH, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_316TANH};
+static PyObject *__pyx_pw_5talib_7_ta_lib_317TANH(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_real = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("str2bytes (wrapper)", 0);
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_338str2bytes(__pyx_self, ((PyObject *)__pyx_v_s));
-
-  /* function exit code */
+  __Pyx_RefNannySetupContext("TANH (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 4947, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4947, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "TANH", 0) < (0)) __PYX_ERR(4, 4947, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("TANH", 1, 1, 1, i); __PYX_ERR(4, 4947, __pyx_L3_error) }
+      }
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4947, __pyx_L3_error)
+    }
+    __pyx_v_real = ((PyArrayObject *)values[0]);
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("TANH", 1, 1, 1, __pyx_nargs); __PYX_ERR(4, 4947, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.TANH", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 4949, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_316TANH(__pyx_self, __pyx_v_real);
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
+  __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_338str2bytes(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_s) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_316TANH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) {
+  npy_intp __pyx_v_length;
+  int __pyx_v_begidx;
+  int __pyx_v_endidx;
+  int __pyx_v_lookback;
+  TA_RetCode __pyx_v_retCode;
+  int __pyx_v_outbegidx;
+  int __pyx_v_outnbelement;
+  PyArrayObject *__pyx_v_outreal = 0;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("str2bytes", 0);
+  PyObject *__pyx_t_1 = NULL;
+  npy_int __pyx_t_2;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("TANH", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_real);
+
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4966, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
+
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
+
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4968, __pyx_L1_error)
+  __pyx_v_begidx = __pyx_t_2;
+
+  __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
+
+  __pyx_v_lookback = (__pyx_v_begidx + TA_TANH_Lookback());
+
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4971, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  __pyx_v_retCode = TA_TANH(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback));
+
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_TANH, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4973, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(__pyx_v_s);
-  __pyx_r = __pyx_v_s;
+  __Pyx_INCREF((PyObject *)__pyx_v_outreal);
+  __pyx_r = ((PyObject *)__pyx_v_outreal);
   goto __pyx_L0;
 
 
   /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("talib._ta_lib.TANH", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
   __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
+  __Pyx_XDECREF((PyObject *)__pyx_v_real);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -31261,32 +38444,176 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_338str2bytes(CYTHON_UNUSED PyObject *_
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_341bytes2str(PyObject *__pyx_self, PyObject *__pyx_v_b); /*proto*/
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_341bytes2str = {"bytes2str", (PyCFunction)__pyx_pw_5talib_7_ta_lib_341bytes2str, METH_O, 0};
-static PyObject *__pyx_pw_5talib_7_ta_lib_341bytes2str(PyObject *__pyx_self, PyObject *__pyx_v_b) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_319TEMA(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_318TEMA, "TEMA(ndarray real, int timeperiod=-0x80000000)\n\nTEMA(real[, timeperiod=?])\n\nTriple Exponential Moving Average (Overlap Studies)\n\nInputs:\n    real: (any ndarray)\nParameters:\n    timeperiod: 30\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_319TEMA = {"TEMA", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_319TEMA, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_318TEMA};
+static PyObject *__pyx_pw_5talib_7_ta_lib_319TEMA(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_real = 0;
+  int __pyx_v_timeperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("bytes2str (wrapper)", 0);
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_340bytes2str(__pyx_self, ((PyObject *)__pyx_v_b));
+  __Pyx_RefNannySetupContext("TEMA (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 4976, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 4976, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4976, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "TEMA", 0) < (0)) __PYX_ERR(4, 4976, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("TEMA", 0, 1, 2, i); __PYX_ERR(4, 4976, __pyx_L3_error) }
+      }
+    } else {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 4976, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 4976, __pyx_L3_error)
+        break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+    }
+    __pyx_v_real = ((PyArrayObject *)values[0]);
+    if (values[1]) {
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4978, __pyx_L3_error)
+    } else {
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
+    }
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("TEMA", 0, 1, 2, __pyx_nargs); __PYX_ERR(4, 4976, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.TEMA", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 4978, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_318TEMA(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
 
   /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
+  __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_340bytes2str(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_b) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_318TEMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
+  npy_intp __pyx_v_length;
+  int __pyx_v_begidx;
+  int __pyx_v_endidx;
+  int __pyx_v_lookback;
+  TA_RetCode __pyx_v_retCode;
+  int __pyx_v_outbegidx;
+  int __pyx_v_outnbelement;
+  PyArrayObject *__pyx_v_outreal = 0;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("bytes2str", 0);
+  PyObject *__pyx_t_1 = NULL;
+  npy_int __pyx_t_2;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("TEMA", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_real);
+
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4997, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
+
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
+
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4999, __pyx_L1_error)
+  __pyx_v_begidx = __pyx_t_2;
+
+  __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
+
+  __pyx_v_lookback = (__pyx_v_begidx + TA_TEMA_Lookback(__pyx_v_timeperiod));
+
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5002, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  __pyx_v_retCode = TA_TEMA(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback));
+
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_TEMA, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5004, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(__pyx_v_b);
-  __pyx_r = __pyx_v_b;
+  __Pyx_INCREF((PyObject *)__pyx_v_outreal);
+  __pyx_r = ((PyObject *)__pyx_v_outreal);
   goto __pyx_L0;
 
 
   /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("talib._ta_lib.TEMA", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
   __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
+  __Pyx_XDECREF((PyObject *)__pyx_v_real);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -31294,264 +38621,193 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_340bytes2str(CYTHON_UNUSED PyObject *_
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_1__init__(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_8Function_1__init__ = {"__init__", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_8Function_1__init__, METH_VARARGS|METH_KEYWORDS, 0};
-static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_1__init__(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyObject *__pyx_v_self = 0;
-  PyObject *__pyx_v_function_name = 0;
-  PyObject *__pyx_v_func_object = 0;
-  PyObject *__pyx_v_args = 0;
-  PyObject *__pyx_v_kwargs = 0;
+static PyObject *__pyx_pw_5talib_7_ta_lib_321TRANGE(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_320TRANGE, "TRANGE(ndarray high, ndarray low, ndarray close)\n\nTRANGE(high, low, close)\n\nTrue Range (Volatility Indicators)\n\nInputs:\n    prices: ['high', 'low', 'close']\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_321TRANGE = {"TRANGE", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_321TRANGE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_320TRANGE};
+static PyObject *__pyx_pw_5talib_7_ta_lib_321TRANGE(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_high = 0;
+  PyArrayObject *__pyx_v_low = 0;
+  PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[3] = {0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__init__ (wrapper)", 0);
-  __pyx_v_kwargs = PyDict_New(); if (unlikely(!__pyx_v_kwargs)) return NULL;
-  __Pyx_GOTREF(__pyx_v_kwargs);
-  if (PyTuple_GET_SIZE(__pyx_args) > 3) {
-    __pyx_v_args = PyTuple_GetSlice(__pyx_args, 3, PyTuple_GET_SIZE(__pyx_args));
-    if (unlikely(!__pyx_v_args)) {
-      __Pyx_DECREF(__pyx_v_kwargs); __pyx_v_kwargs = 0;
-      __Pyx_RefNannyFinishContext();
-      return NULL;
-    }
-    __Pyx_GOTREF(__pyx_v_args);
-  } else {
-    __pyx_v_args = __pyx_empty_tuple; __Pyx_INCREF(__pyx_empty_tuple);
-  }
+  __Pyx_RefNannySetupContext("TRANGE (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self,&__pyx_n_s_function_name,&__pyx_n_s_func_object,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) {
-        default:
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 5007, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 5007, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  0: break;
-      }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_self)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 5007, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_function_name)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("__init__", 0, 3, 3, 1); __PYX_ERR(1, 90, __pyx_L3_error)
-        }
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 5007, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_func_object)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("__init__", 0, 3, 3, 2); __PYX_ERR(1, 90, __pyx_L3_error)
-        }
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
       }
-      if (unlikely(kw_args > 0)) {
-        const Py_ssize_t used_pos_args = (pos_args < 3) ? pos_args : 3;
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, __pyx_v_kwargs, values, used_pos_args, "__init__") < 0)) __PYX_ERR(1, 90, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "TRANGE", 0) < (0)) __PYX_ERR(4, 5007, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 3; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("TRANGE", 1, 3, 3, i); __PYX_ERR(4, 5007, __pyx_L3_error) }
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) < 3) {
+    } else if (unlikely(__pyx_nargs != 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);
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 5007, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 5007, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 5007, __pyx_L3_error)
     }
-    __pyx_v_self = values[0];
-    __pyx_v_function_name = values[1];
-    __pyx_v_func_object = values[2];
+    __pyx_v_high = ((PyArrayObject *)values[0]);
+    __pyx_v_low = ((PyArrayObject *)values[1]);
+    __pyx_v_close = ((PyArrayObject *)values[2]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("__init__", 0, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 90, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("TRANGE", 1, 3, 3, __pyx_nargs); __PYX_ERR(4, 5007, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_DECREF(__pyx_v_args); __pyx_v_args = 0;
-  __Pyx_DECREF(__pyx_v_kwargs); __pyx_v_kwargs = 0;
-  __Pyx_AddTraceback("talib._ta_lib.Function.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.TRANGE", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_8Function___init__(__pyx_self, __pyx_v_self, __pyx_v_function_name, __pyx_v_func_object, __pyx_v_args, __pyx_v_kwargs);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 5009, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 5009, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 5009, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_320TRANGE(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
-  __Pyx_XDECREF(__pyx_v_args);
-  __Pyx_XDECREF(__pyx_v_kwargs);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
+  __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_8Function___init__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_function_name, PyObject *__pyx_v_func_object, PyObject *__pyx_v_args, PyObject *__pyx_v_kwargs) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_320TRANGE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+  npy_intp __pyx_v_length;
+  int __pyx_v_begidx;
+  int __pyx_v_endidx;
+  int __pyx_v_lookback;
+  TA_RetCode __pyx_v_retCode;
+  int __pyx_v_outbegidx;
+  int __pyx_v_outnbelement;
+  PyArrayObject *__pyx_v_outreal = 0;
   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("__init__", 0);
+  npy_intp __pyx_t_2;
+  npy_int __pyx_t_3;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("TRANGE", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_high);
+  __Pyx_INCREF((PyObject *)__pyx_v_low);
+  __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_function_name, __pyx_n_s_upper); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 92, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = NULL;
-  if (CYTHON_UNPACK_METHODS && likely(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);
-    }
-  }
-  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2);
-  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
-  if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 92, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5026, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_Function__name, __pyx_t_1) < 0) __PYX_ERR(1, 92, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
 
-  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__name); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 93, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5027, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_Function__namestr, __pyx_t_1) < 0) __PYX_ERR(1, 93, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
 
-  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_str2bytes); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 94, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__name); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 94, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __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);
-    }
-  }
-  __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3);
-  __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 94, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5028, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_Function__name, __pyx_t_1) < 0) __PYX_ERR(1, 94, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
 
-  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_Function__info, Py_None) < 0) __PYX_ERR(1, 95, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 5029, __pyx_L1_error)
+  __pyx_v_length = __pyx_t_2;
 
-  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_INPUT_ARRAYS_DEFAULTS); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 96, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_Function__input_arrays, __pyx_t_1) < 0) __PYX_ERR(1, 96, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx3(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 5030, __pyx_L1_error)
+  __pyx_v_begidx = __pyx_t_3;
 
-  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_OrderedDict); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 99, __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);
-    }
-  }
-  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2);
-  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
-  if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 99, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_Function__input_names, __pyx_t_1) < 0) __PYX_ERR(1, 99, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_OrderedDict); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 100, __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);
-    }
-  }
-  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2);
-  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
-  if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 100, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_Function__opt_inputs, __pyx_t_1) < 0) __PYX_ERR(1, 100, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v_lookback = (__pyx_v_begidx + TA_TRANGE_Lookback());
 
-  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_OrderedDict); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 101, __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);
-    }
-  }
-  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2);
-  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
-  if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 101, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5033, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_Function__outputs, __pyx_t_1) < 0) __PYX_ERR(1, 101, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-
-  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_Function__outputs_valid, Py_False) < 0) __PYX_ERR(1, 102, __pyx_L1_error)
+  __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
+  __pyx_t_1 = 0;
 
-  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__initialize_function_i); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 105, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = NULL;
-  if (CYTHON_UNPACK_METHODS && likely(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);
-    }
-  }
-  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2);
-  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
-  if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 105, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v_retCode = TA_TRANGE(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_set_function_args); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 106, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_TRANGE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5035, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_v_args, __pyx_v_kwargs); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 106, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_func_object, __pyx_v_func_object) < 0) __PYX_ERR(1, 107, __pyx_L1_error)
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF((PyObject *)__pyx_v_outreal);
+  __pyx_r = ((PyObject *)__pyx_v_outreal);
+  goto __pyx_L0;
 
 
   /* function exit code */
-  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
-  goto __pyx_L0;
   __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("talib._ta_lib.Function.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.TRANGE", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
+  __Pyx_XDECREF((PyObject *)__pyx_v_high);
+  __Pyx_XDECREF((PyObject *)__pyx_v_low);
+  __Pyx_XDECREF((PyObject *)__pyx_v_close);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -31559,556 +38815,176 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function___init__(CYTHON_UNUSED PyObj
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_3__initialize_function_info(PyObject *__pyx_self, PyObject *__pyx_v_self); /*proto*/
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_8Function_3__initialize_function_info = {"__initialize_function_info", (PyCFunction)__pyx_pw_5talib_7_ta_lib_8Function_3__initialize_function_info, METH_O, 0};
-static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_3__initialize_function_info(PyObject *__pyx_self, PyObject *__pyx_v_self) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_323TRIMA(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_322TRIMA, "TRIMA(ndarray real, int timeperiod=-0x80000000)\n\nTRIMA(real[, timeperiod=?])\n\nTriangular Moving Average (Overlap Studies)\n\nInputs:\n    real: (any ndarray)\nParameters:\n    timeperiod: 30\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_323TRIMA = {"TRIMA", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_323TRIMA, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_322TRIMA};
+static PyObject *__pyx_pw_5talib_7_ta_lib_323TRIMA(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_real = 0;
+  int __pyx_v_timeperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__initialize_function_info (wrapper)", 0);
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_8Function_2__initialize_function_info(__pyx_self, ((PyObject *)__pyx_v_self));
+  __Pyx_RefNannySetupContext("TRIMA (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 5038, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 5038, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 5038, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "TRIMA", 0) < (0)) __PYX_ERR(4, 5038, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("TRIMA", 0, 1, 2, i); __PYX_ERR(4, 5038, __pyx_L3_error) }
+      }
+    } else {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 5038, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 5038, __pyx_L3_error)
+        break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+    }
+    __pyx_v_real = ((PyArrayObject *)values[0]);
+    if (values[1]) {
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 5040, __pyx_L3_error)
+    } else {
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
+    }
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("TRIMA", 0, 1, 2, __pyx_nargs); __PYX_ERR(4, 5038, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.TRIMA", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 5040, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_322TRIMA(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
 
   /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
+  __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_2__initialize_function_info(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
-  PyObject *__pyx_v_i = NULL;
-  PyObject *__pyx_v_info = NULL;
-  PyObject *__pyx_v_input_name = NULL;
-  PyObject *__pyx_v_param_name = NULL;
-  PyObject *__pyx_v_output_name = NULL;
+static PyObject *__pyx_pf_5talib_7_ta_lib_322TRIMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
+  npy_intp __pyx_v_length;
+  int __pyx_v_begidx;
+  int __pyx_v_endidx;
+  int __pyx_v_lookback;
+  TA_RetCode __pyx_v_retCode;
+  int __pyx_v_outbegidx;
+  int __pyx_v_outnbelement;
+  PyArrayObject *__pyx_v_outreal = 0;
   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;
-  Py_ssize_t __pyx_t_5;
-  PyObject *(*__pyx_t_6)(PyObject *);
-  PyObject *__pyx_t_7 = NULL;
-  int __pyx_t_8;
-  PyObject *__pyx_t_9 = NULL;
-  int __pyx_t_10;
-  int __pyx_t_11;
-  __Pyx_RefNannySetupContext("__initialize_function_info", 0);
-
-  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_ta_getFuncInfo); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 111, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__name); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 111, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __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);
-    }
-  }
-  __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3);
-  __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 111, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_Function__info, __pyx_t_1) < 0) __PYX_ERR(1, 111, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  npy_int __pyx_t_2;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("TRIMA", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__info); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 114, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_pop); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 114, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __pyx_t_2 = NULL;
-  if (CYTHON_UNPACK_METHODS && likely(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_1 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_2, __pyx_n_s_num_inputs) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_n_s_num_inputs);
-  __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
-  if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 114, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5059, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_xrange, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 114, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  if (likely(PyList_CheckExact(__pyx_t_3)) || PyTuple_CheckExact(__pyx_t_3)) {
-    __pyx_t_1 = __pyx_t_3; __Pyx_INCREF(__pyx_t_1); __pyx_t_5 = 0;
-    __pyx_t_6 = NULL;
-  } else {
-    __pyx_t_5 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 114, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_1);
-    __pyx_t_6 = Py_TYPE(__pyx_t_1)->tp_iternext; if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 114, __pyx_L1_error)
-  }
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  for (;;) {
-    if (likely(!__pyx_t_6)) {
-      if (likely(PyList_CheckExact(__pyx_t_1))) {
-        if (__pyx_t_5 >= PyList_GET_SIZE(__pyx_t_1)) break;
-        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-        __pyx_t_3 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_5); __Pyx_INCREF(__pyx_t_3); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(1, 114, __pyx_L1_error)
-        #else
-        __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 114, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_3);
-        #endif
-      } else {
-        if (__pyx_t_5 >= 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_5); __Pyx_INCREF(__pyx_t_3); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(1, 114, __pyx_L1_error)
-        #else
-        __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 114, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_3);
-        #endif
-      }
-    } else {
-      __pyx_t_3 = __pyx_t_6(__pyx_t_1);
-      if (unlikely(!__pyx_t_3)) {
-        PyObject* exc_type = PyErr_Occurred();
-        if (exc_type) {
-          if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
-          else __PYX_ERR(1, 114, __pyx_L1_error)
-        }
-        break;
-      }
-      __Pyx_GOTREF(__pyx_t_3);
-    }
-    __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_3);
-    __pyx_t_3 = 0;
-
-    __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_ta_getInputParameterInfo); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 115, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_2);
-    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__name); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 115, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_4);
-    __pyx_t_7 = NULL;
-    __pyx_t_8 = 0;
-    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) {
-      __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_2);
-      if (likely(__pyx_t_7)) {
-        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
-        __Pyx_INCREF(__pyx_t_7);
-        __Pyx_INCREF(function);
-        __Pyx_DECREF_SET(__pyx_t_2, function);
-        __pyx_t_8 = 1;
-      }
-    }
-    #if CYTHON_FAST_PYCALL
-    if (PyFunction_Check(__pyx_t_2)) {
-      PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_t_4, __pyx_v_i};
-      __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 115, __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_2)) {
-      PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_t_4, __pyx_v_i};
-      __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 115, __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_9 = PyTuple_New(2+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 115, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_9);
-      if (__pyx_t_7) {
-        __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_7); __pyx_t_7 = NULL;
-      }
-      __Pyx_GIVEREF(__pyx_t_4);
-      PyTuple_SET_ITEM(__pyx_t_9, 0+__pyx_t_8, __pyx_t_4);
-      __Pyx_INCREF(__pyx_v_i);
-      __Pyx_GIVEREF(__pyx_v_i);
-      PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_8, __pyx_v_i);
-      __pyx_t_4 = 0;
-      __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_9, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 115, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_3);
-      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
-    }
-    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-    __Pyx_XDECREF_SET(__pyx_v_info, __pyx_t_3);
-    __pyx_t_3 = 0;
+  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
 
-    __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_info, __pyx_n_s_name); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 116, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_3);
-    __Pyx_XDECREF_SET(__pyx_v_input_name, __pyx_t_3);
-    __pyx_t_3 = 0;
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
-    __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_info, __pyx_n_s_price_series); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 117, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_3);
-    __pyx_t_10 = (__pyx_t_3 == Py_None);
-    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-    __pyx_t_11 = (__pyx_t_10 != 0);
-    if (__pyx_t_11) {
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 5061, __pyx_L1_error)
+  __pyx_v_begidx = __pyx_t_2;
 
-      __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_INPUT_PRICE_SERIES_DEFAULTS); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 118, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_3);
-      __pyx_t_2 = __Pyx_PyObject_GetItem(__pyx_t_3, __pyx_v_input_name); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 118, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_2);
-      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-      if (unlikely(PyObject_SetItem(__pyx_v_info, __pyx_n_s_price_series, __pyx_t_2) < 0)) __PYX_ERR(1, 118, __pyx_L1_error)
-      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-    }
+  __pyx_v_lookback = (__pyx_v_begidx + TA_TRIMA_Lookback(__pyx_v_timeperiod));
 
-    __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__input_names); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 119, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_2);
-    if (unlikely(PyObject_SetItem(__pyx_t_2, __pyx_v_input_name, __pyx_v_info) < 0)) __PYX_ERR(1, 119, __pyx_L1_error)
-    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5064, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
+  __pyx_t_1 = 0;
 
-  }
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v_retCode = TA_TRIMA(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback));
 
-  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_input_names); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 120, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_TRIMA, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5066, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__info); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 120, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  if (unlikely(PyObject_SetItem(__pyx_t_2, __pyx_n_s_input_names, __pyx_t_1) < 0)) __PYX_ERR(1, 120, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
-  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__info); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 123, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_pop); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 123, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __pyx_t_2 = NULL;
-  if (CYTHON_UNPACK_METHODS && likely(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_1 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_2, __pyx_n_s_num_opt_inputs) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_n_s_num_opt_inputs);
-  __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
-  if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 123, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_xrange, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 123, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  if (likely(PyList_CheckExact(__pyx_t_3)) || PyTuple_CheckExact(__pyx_t_3)) {
-    __pyx_t_1 = __pyx_t_3; __Pyx_INCREF(__pyx_t_1); __pyx_t_5 = 0;
-    __pyx_t_6 = NULL;
-  } else {
-    __pyx_t_5 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 123, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_1);
-    __pyx_t_6 = Py_TYPE(__pyx_t_1)->tp_iternext; if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 123, __pyx_L1_error)
-  }
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  for (;;) {
-    if (likely(!__pyx_t_6)) {
-      if (likely(PyList_CheckExact(__pyx_t_1))) {
-        if (__pyx_t_5 >= PyList_GET_SIZE(__pyx_t_1)) break;
-        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-        __pyx_t_3 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_5); __Pyx_INCREF(__pyx_t_3); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(1, 123, __pyx_L1_error)
-        #else
-        __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 123, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_3);
-        #endif
-      } else {
-        if (__pyx_t_5 >= 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_5); __Pyx_INCREF(__pyx_t_3); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(1, 123, __pyx_L1_error)
-        #else
-        __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 123, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_3);
-        #endif
-      }
-    } else {
-      __pyx_t_3 = __pyx_t_6(__pyx_t_1);
-      if (unlikely(!__pyx_t_3)) {
-        PyObject* exc_type = PyErr_Occurred();
-        if (exc_type) {
-          if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
-          else __PYX_ERR(1, 123, __pyx_L1_error)
-        }
-        break;
-      }
-      __Pyx_GOTREF(__pyx_t_3);
-    }
-    __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_3);
-    __pyx_t_3 = 0;
-
-    __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_ta_getOptInputParameterInfo); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 124, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_2);
-    __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__name); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 124, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_9);
-    __pyx_t_4 = NULL;
-    __pyx_t_8 = 0;
-    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);
-        __pyx_t_8 = 1;
-      }
-    }
-    #if CYTHON_FAST_PYCALL
-    if (PyFunction_Check(__pyx_t_2)) {
-      PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_t_9, __pyx_v_i};
-      __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 124, __pyx_L1_error)
-      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
-      __Pyx_GOTREF(__pyx_t_3);
-      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
-    } else
-    #endif
-    #if CYTHON_FAST_PYCCALL
-    if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
-      PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_t_9, __pyx_v_i};
-      __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 124, __pyx_L1_error)
-      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
-      __Pyx_GOTREF(__pyx_t_3);
-      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
-    } else
-    #endif
-    {
-      __pyx_t_7 = PyTuple_New(2+__pyx_t_8); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 124, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_7);
-      if (__pyx_t_4) {
-        __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_4); __pyx_t_4 = NULL;
-      }
-      __Pyx_GIVEREF(__pyx_t_9);
-      PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_8, __pyx_t_9);
-      __Pyx_INCREF(__pyx_v_i);
-      __Pyx_GIVEREF(__pyx_v_i);
-      PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_8, __pyx_v_i);
-      __pyx_t_9 = 0;
-      __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_7, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 124, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_3);
-      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
-    }
-    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-    __Pyx_XDECREF_SET(__pyx_v_info, __pyx_t_3);
-    __pyx_t_3 = 0;
-
-    __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_info, __pyx_n_s_name); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 125, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_3);
-    __Pyx_XDECREF_SET(__pyx_v_param_name, __pyx_t_3);
-    __pyx_t_3 = 0;
-
-    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__opt_inputs); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 126, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_3);
-    if (unlikely(PyObject_SetItem(__pyx_t_3, __pyx_v_param_name, __pyx_v_info) < 0)) __PYX_ERR(1, 126, __pyx_L1_error)
-    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-
-  }
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-
-  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_parameters); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 127, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__info); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 127, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (unlikely(PyObject_SetItem(__pyx_t_3, __pyx_n_s_parameters, __pyx_t_1) < 0)) __PYX_ERR(1, 127, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-
-  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_OrderedDict); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 130, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_2 = NULL;
-  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_1 = (__pyx_t_2) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2) : __Pyx_PyObject_CallNoArg(__pyx_t_3);
-  __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
-  if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 130, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__info); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 130, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (unlikely(PyObject_SetItem(__pyx_t_3, __pyx_n_s_output_flags, __pyx_t_1) < 0)) __PYX_ERR(1, 130, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-
-  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__info); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 131, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_pop); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 131, __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 && likely(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);
-    }
-  }
-  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_n_s_num_outputs) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_n_s_num_outputs);
-  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
-  if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 131, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_xrange, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 131, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  if (likely(PyList_CheckExact(__pyx_t_2)) || PyTuple_CheckExact(__pyx_t_2)) {
-    __pyx_t_1 = __pyx_t_2; __Pyx_INCREF(__pyx_t_1); __pyx_t_5 = 0;
-    __pyx_t_6 = NULL;
-  } else {
-    __pyx_t_5 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 131, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_1);
-    __pyx_t_6 = Py_TYPE(__pyx_t_1)->tp_iternext; if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 131, __pyx_L1_error)
-  }
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  for (;;) {
-    if (likely(!__pyx_t_6)) {
-      if (likely(PyList_CheckExact(__pyx_t_1))) {
-        if (__pyx_t_5 >= PyList_GET_SIZE(__pyx_t_1)) break;
-        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-        __pyx_t_2 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_5); __Pyx_INCREF(__pyx_t_2); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(1, 131, __pyx_L1_error)
-        #else
-        __pyx_t_2 = PySequence_ITEM(__pyx_t_1, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 131, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_2);
-        #endif
-      } else {
-        if (__pyx_t_5 >= PyTuple_GET_SIZE(__pyx_t_1)) break;
-        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-        __pyx_t_2 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_5); __Pyx_INCREF(__pyx_t_2); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(1, 131, __pyx_L1_error)
-        #else
-        __pyx_t_2 = PySequence_ITEM(__pyx_t_1, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 131, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_2);
-        #endif
-      }
-    } else {
-      __pyx_t_2 = __pyx_t_6(__pyx_t_1);
-      if (unlikely(!__pyx_t_2)) {
-        PyObject* exc_type = PyErr_Occurred();
-        if (exc_type) {
-          if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
-          else __PYX_ERR(1, 131, __pyx_L1_error)
-        }
-        break;
-      }
-      __Pyx_GOTREF(__pyx_t_2);
-    }
-    __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_2);
-    __pyx_t_2 = 0;
-
-    __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_ta_getOutputParameterInfo); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 132, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_3);
-    __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__name); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 132, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_7);
-    __pyx_t_9 = NULL;
-    __pyx_t_8 = 0;
-    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);
-        __pyx_t_8 = 1;
-      }
-    }
-    #if CYTHON_FAST_PYCALL
-    if (PyFunction_Check(__pyx_t_3)) {
-      PyObject *__pyx_temp[3] = {__pyx_t_9, __pyx_t_7, __pyx_v_i};
-      __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 132, __pyx_L1_error)
-      __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
-      __Pyx_GOTREF(__pyx_t_2);
-      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
-    } else
-    #endif
-    #if CYTHON_FAST_PYCCALL
-    if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
-      PyObject *__pyx_temp[3] = {__pyx_t_9, __pyx_t_7, __pyx_v_i};
-      __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 132, __pyx_L1_error)
-      __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
-      __Pyx_GOTREF(__pyx_t_2);
-      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
-    } else
-    #endif
-    {
-      __pyx_t_4 = PyTuple_New(2+__pyx_t_8); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 132, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_4);
-      if (__pyx_t_9) {
-        __Pyx_GIVEREF(__pyx_t_9); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_9); __pyx_t_9 = NULL;
-      }
-      __Pyx_GIVEREF(__pyx_t_7);
-      PyTuple_SET_ITEM(__pyx_t_4, 0+__pyx_t_8, __pyx_t_7);
-      __Pyx_INCREF(__pyx_v_i);
-      __Pyx_GIVEREF(__pyx_v_i);
-      PyTuple_SET_ITEM(__pyx_t_4, 1+__pyx_t_8, __pyx_v_i);
-      __pyx_t_7 = 0;
-      __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_4, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 132, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_2);
-      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-    }
-    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-    __Pyx_XDECREF_SET(__pyx_v_info, __pyx_t_2);
-    __pyx_t_2 = 0;
-
-    __pyx_t_2 = __Pyx_PyObject_Dict_GetItem(__pyx_v_info, __pyx_n_s_name); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 133, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_2);
-    __Pyx_XDECREF_SET(__pyx_v_output_name, __pyx_t_2);
-    __pyx_t_2 = 0;
-
-    __pyx_t_2 = __Pyx_PyObject_Dict_GetItem(__pyx_v_info, __pyx_n_s_flags); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 134, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_2);
-    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__info); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 134, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_3);
-    __pyx_t_4 = __Pyx_PyObject_Dict_GetItem(__pyx_t_3, __pyx_n_s_output_flags); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 134, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_4);
-    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-    if (unlikely(PyObject_SetItem(__pyx_t_4, __pyx_v_output_name, __pyx_t_2) < 0)) __PYX_ERR(1, 134, __pyx_L1_error)
-    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-
-    __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__outputs); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 135, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_2);
-    if (unlikely(PyObject_SetItem(__pyx_t_2, __pyx_v_output_name, Py_None) < 0)) __PYX_ERR(1, 135, __pyx_L1_error)
-    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-
-  }
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-
-  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_output_names); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 136, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__info); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 136, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  if (unlikely(PyObject_SetItem(__pyx_t_2, __pyx_n_s_output_names, __pyx_t_1) < 0)) __PYX_ERR(1, 136, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF((PyObject *)__pyx_v_outreal);
+  __pyx_r = ((PyObject *)__pyx_v_outreal);
+  goto __pyx_L0;
 
 
   /* function exit code */
-  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
-  goto __pyx_L0;
   __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_7);
-  __Pyx_XDECREF(__pyx_t_9);
-  __Pyx_AddTraceback("talib._ta_lib.Function.__initialize_function_info", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.TRIMA", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF(__pyx_v_i);
-  __Pyx_XDECREF(__pyx_v_info);
-  __Pyx_XDECREF(__pyx_v_input_name);
-  __Pyx_XDECREF(__pyx_v_param_name);
-  __Pyx_XDECREF(__pyx_v_output_name);
+  __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
+  __Pyx_XDECREF((PyObject *)__pyx_v_real);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -32116,108 +38992,176 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_2__initialize_function_info(
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_5info(PyObject *__pyx_self, PyObject *__pyx_v_self); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_8Function_4info[] = "\n        Returns a copy of the function's info dict.\n        ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_8Function_5info = {"info", (PyCFunction)__pyx_pw_5talib_7_ta_lib_8Function_5info, METH_O, __pyx_doc_5talib_7_ta_lib_8Function_4info};
-static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_5info(PyObject *__pyx_self, PyObject *__pyx_v_self) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_325TRIX(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_324TRIX, "TRIX(ndarray real, int timeperiod=-0x80000000)\n\nTRIX(real[, timeperiod=?])\n\n1-day Rate-Of-Change (ROC) of a Triple Smooth EMA (Momentum Indicators)\n\nInputs:\n    real: (any ndarray)\nParameters:\n    timeperiod: 30\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_325TRIX = {"TRIX", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_325TRIX, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_324TRIX};
+static PyObject *__pyx_pw_5talib_7_ta_lib_325TRIX(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_real = 0;
+  int __pyx_v_timeperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("info (wrapper)", 0);
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_8Function_4info(__pyx_self, ((PyObject *)__pyx_v_self));
+  __Pyx_RefNannySetupContext("TRIX (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 5069, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 5069, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 5069, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "TRIX", 0) < (0)) __PYX_ERR(4, 5069, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("TRIX", 0, 1, 2, i); __PYX_ERR(4, 5069, __pyx_L3_error) }
+      }
+    } else {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 5069, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 5069, __pyx_L3_error)
+        break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+    }
+    __pyx_v_real = ((PyArrayObject *)values[0]);
+    if (values[1]) {
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 5071, __pyx_L3_error)
+    } else {
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
+    }
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("TRIX", 0, 1, 2, __pyx_nargs); __PYX_ERR(4, 5069, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.TRIX", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 5071, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_324TRIX(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
 
   /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
+  __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_4info(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_324TRIX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
+  npy_intp __pyx_v_length;
+  int __pyx_v_begidx;
+  int __pyx_v_endidx;
+  int __pyx_v_lookback;
+  TA_RetCode __pyx_v_retCode;
+  int __pyx_v_outbegidx;
+  int __pyx_v_outnbelement;
+  PyArrayObject *__pyx_v_outreal = 0;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  PyObject *__pyx_t_2 = NULL;
-  PyObject *__pyx_t_3 = NULL;
-  __Pyx_RefNannySetupContext("info", 0);
+  npy_int __pyx_t_2;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("TRIX", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __Pyx_XDECREF(__pyx_r);
-  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__info); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 143, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_copy); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 143, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __pyx_t_2 = NULL;
-  if (CYTHON_UNPACK_METHODS && likely(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_1 = (__pyx_t_2) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2) : __Pyx_PyObject_CallNoArg(__pyx_t_3);
-  __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
-  if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 143, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5090, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __pyx_r = __pyx_t_1;
+  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
-  goto __pyx_L0;
 
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
-  /* function exit code */
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_XDECREF(__pyx_t_2);
-  __Pyx_XDECREF(__pyx_t_3);
-  __Pyx_AddTraceback("talib._ta_lib.Function.info", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = NULL;
-  __pyx_L0:;
-  __Pyx_XGIVEREF(__pyx_r);
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 5092, __pyx_L1_error)
+  __pyx_v_begidx = __pyx_t_2;
 
+  __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-/* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_7function_flags(PyObject *__pyx_self, PyObject *__pyx_v_self); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_8Function_6function_flags[] = "\n        Returns any function flags defined for this indicator function.\n        ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_8Function_7function_flags = {"function_flags", (PyCFunction)__pyx_pw_5talib_7_ta_lib_8Function_7function_flags, METH_O, __pyx_doc_5talib_7_ta_lib_8Function_6function_flags};
-static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_7function_flags(PyObject *__pyx_self, PyObject *__pyx_v_self) {
-  PyObject *__pyx_r = 0;
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("function_flags (wrapper)", 0);
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_8Function_6function_flags(__pyx_self, ((PyObject *)__pyx_v_self));
+  __pyx_v_lookback = (__pyx_v_begidx + TA_TRIX_Lookback(__pyx_v_timeperiod));
 
-  /* function exit code */
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5095, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
+  __pyx_t_1 = 0;
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_6function_flags(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
-  PyObject *__pyx_r = NULL;
-  __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
-  PyObject *__pyx_t_2 = NULL;
-  __Pyx_RefNannySetupContext("function_flags", 0);
+  __pyx_v_retCode = TA_TRIX(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback));
 
-  __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__info); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 150, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_TRIX, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5097, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = __Pyx_PyObject_Dict_GetItem(__pyx_t_1, __pyx_n_s_function_flags); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 150, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_r = __pyx_t_2;
-  __pyx_t_2 = 0;
+
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF((PyObject *)__pyx_v_outreal);
+  __pyx_r = ((PyObject *)__pyx_v_outreal);
   goto __pyx_L0;
 
 
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_XDECREF(__pyx_t_2);
-  __Pyx_AddTraceback("talib._ta_lib.Function.function_flags", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.TRIX", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
+  __Pyx_XDECREF((PyObject *)__pyx_v_real);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -32225,193 +39169,176 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_6function_flags(CYTHON_UNUSE
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_9output_flags(PyObject *__pyx_self, PyObject *__pyx_v_self); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_8Function_8output_flags[] = "\n        Returns the flags for each output for this indicator function.\n        ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_8Function_9output_flags = {"output_flags", (PyCFunction)__pyx_pw_5talib_7_ta_lib_8Function_9output_flags, METH_O, __pyx_doc_5talib_7_ta_lib_8Function_8output_flags};
-static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_9output_flags(PyObject *__pyx_self, PyObject *__pyx_v_self) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_327TSF(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_326TSF, "TSF(ndarray real, int timeperiod=-0x80000000)\n\nTSF(real[, timeperiod=?])\n\nTime Series Forecast (Statistic Functions)\n\nInputs:\n    real: (any ndarray)\nParameters:\n    timeperiod: 14\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_327TSF = {"TSF", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_327TSF, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_326TSF};
+static PyObject *__pyx_pw_5talib_7_ta_lib_327TSF(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_real = 0;
+  int __pyx_v_timeperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("output_flags (wrapper)", 0);
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_8Function_8output_flags(__pyx_self, ((PyObject *)__pyx_v_self));
+  __Pyx_RefNannySetupContext("TSF (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 5100, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 5100, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 5100, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "TSF", 0) < (0)) __PYX_ERR(4, 5100, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("TSF", 0, 1, 2, i); __PYX_ERR(4, 5100, __pyx_L3_error) }
+      }
+    } else {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 5100, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 5100, __pyx_L3_error)
+        break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+    }
+    __pyx_v_real = ((PyArrayObject *)values[0]);
+    if (values[1]) {
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 5102, __pyx_L3_error)
+    } else {
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
+    }
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("TSF", 0, 1, 2, __pyx_nargs); __PYX_ERR(4, 5100, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.TSF", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 5102, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_326TSF(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
 
   /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
+  __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_8output_flags(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_326TSF(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
+  npy_intp __pyx_v_length;
+  int __pyx_v_begidx;
+  int __pyx_v_endidx;
+  int __pyx_v_lookback;
+  TA_RetCode __pyx_v_retCode;
+  int __pyx_v_outbegidx;
+  int __pyx_v_outnbelement;
+  PyArrayObject *__pyx_v_outreal = 0;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  PyObject *__pyx_t_2 = NULL;
-  PyObject *__pyx_t_3 = NULL;
-  __Pyx_RefNannySetupContext("output_flags", 0);
+  npy_int __pyx_t_2;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("TSF", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __Pyx_XDECREF(__pyx_r);
-  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__info); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 157, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_t_2, __pyx_n_s_output_flags); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 157, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_copy); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 157, __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 && likely(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);
-    }
-  }
-  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2);
-  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
-  if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 157, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5121, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __pyx_r = __pyx_t_1;
+  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
-  goto __pyx_L0;
-
-
-  /* function exit code */
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_XDECREF(__pyx_t_2);
-  __Pyx_XDECREF(__pyx_t_3);
-  __Pyx_AddTraceback("talib._ta_lib.Function.output_flags", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = NULL;
-  __pyx_L0:;
-  __Pyx_XGIVEREF(__pyx_r);
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
 
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
-/* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_11get_input_names(PyObject *__pyx_self, PyObject *__pyx_v_self); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_8Function_10get_input_names[] = "\n        Returns the dict of input price series names that specifies which\n        of the ndarrays in input_arrays will be used to calculate the function.\n        ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_8Function_11get_input_names = {"get_input_names", (PyCFunction)__pyx_pw_5talib_7_ta_lib_8Function_11get_input_names, METH_O, __pyx_doc_5talib_7_ta_lib_8Function_10get_input_names};
-static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_11get_input_names(PyObject *__pyx_self, PyObject *__pyx_v_self) {
-  PyObject *__pyx_r = 0;
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("get_input_names (wrapper)", 0);
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_8Function_10get_input_names(__pyx_self, ((PyObject *)__pyx_v_self));
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 5123, __pyx_L1_error)
+  __pyx_v_begidx = __pyx_t_2;
 
-  /* function exit code */
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
+  __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_10get_input_names(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
-  PyObject *__pyx_v_ret = NULL;
-  PyObject *__pyx_v_input_name = NULL;
-  PyObject *__pyx_r = NULL;
-  __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
-  PyObject *__pyx_t_2 = NULL;
-  PyObject *__pyx_t_3 = NULL;
-  Py_ssize_t __pyx_t_4;
-  PyObject *(*__pyx_t_5)(PyObject *);
-  __Pyx_RefNannySetupContext("get_input_names", 0);
+  __pyx_v_lookback = (__pyx_v_begidx + TA_TSF_Lookback(__pyx_v_timeperiod));
 
-  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_OrderedDict); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 164, __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);
-    }
-  }
-  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2);
-  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
-  if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 164, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5126, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __pyx_v_ret = __pyx_t_1;
+  __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__input_names); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 165, __pyx_L1_error)
+  __pyx_v_retCode = TA_TSF(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback));
+
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_TSF, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5128, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  if (likely(PyList_CheckExact(__pyx_t_1)) || PyTuple_CheckExact(__pyx_t_1)) {
-    __pyx_t_2 = __pyx_t_1; __Pyx_INCREF(__pyx_t_2); __pyx_t_4 = 0;
-    __pyx_t_5 = NULL;
-  } else {
-    __pyx_t_4 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 165, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_2);
-    __pyx_t_5 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 165, __pyx_L1_error)
-  }
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  for (;;) {
-    if (likely(!__pyx_t_5)) {
-      if (likely(PyList_CheckExact(__pyx_t_2))) {
-        if (__pyx_t_4 >= PyList_GET_SIZE(__pyx_t_2)) break;
-        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-        __pyx_t_1 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_4); __Pyx_INCREF(__pyx_t_1); __pyx_t_4++; if (unlikely(0 < 0)) __PYX_ERR(1, 165, __pyx_L1_error)
-        #else
-        __pyx_t_1 = PySequence_ITEM(__pyx_t_2, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 165, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_1);
-        #endif
-      } else {
-        if (__pyx_t_4 >= PyTuple_GET_SIZE(__pyx_t_2)) break;
-        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-        __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_4); __Pyx_INCREF(__pyx_t_1); __pyx_t_4++; if (unlikely(0 < 0)) __PYX_ERR(1, 165, __pyx_L1_error)
-        #else
-        __pyx_t_1 = PySequence_ITEM(__pyx_t_2, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 165, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_1);
-        #endif
-      }
-    } else {
-      __pyx_t_1 = __pyx_t_5(__pyx_t_2);
-      if (unlikely(!__pyx_t_1)) {
-        PyObject* exc_type = PyErr_Occurred();
-        if (exc_type) {
-          if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
-          else __PYX_ERR(1, 165, __pyx_L1_error)
-        }
-        break;
-      }
-      __Pyx_GOTREF(__pyx_t_1);
-    }
-    __Pyx_XDECREF_SET(__pyx_v_input_name, __pyx_t_1);
-    __pyx_t_1 = 0;
-
-    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__input_names); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 166, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_1);
-    __pyx_t_3 = __Pyx_PyObject_GetItem(__pyx_t_1, __pyx_v_input_name); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 166, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_3);
-    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-    __pyx_t_1 = __Pyx_PyObject_Dict_GetItem(__pyx_t_3, __pyx_n_s_price_series); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 166, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_1);
-    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-    if (unlikely(PyObject_SetItem(__pyx_v_ret, __pyx_v_input_name, __pyx_t_1) < 0)) __PYX_ERR(1, 166, __pyx_L1_error)
-    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-
-  }
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(__pyx_v_ret);
-  __pyx_r = __pyx_v_ret;
+  __Pyx_INCREF((PyObject *)__pyx_v_outreal);
+  __pyx_r = ((PyObject *)__pyx_v_outreal);
   goto __pyx_L0;
 
 
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_XDECREF(__pyx_t_2);
-  __Pyx_XDECREF(__pyx_t_3);
-  __Pyx_AddTraceback("talib._ta_lib.Function.get_input_names", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.TSF", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF(__pyx_v_ret);
-  __Pyx_XDECREF(__pyx_v_input_name);
+  __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
+  __Pyx_XDECREF((PyObject *)__pyx_v_real);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -32419,227 +39346,193 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_10get_input_names(CYTHON_UNU
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_13set_input_names(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_8Function_12set_input_names[] = "\n        Sets the input price series names to use.\n        ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_8Function_13set_input_names = {"set_input_names", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_8Function_13set_input_names, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_8Function_12set_input_names};
-static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_13set_input_names(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyObject *__pyx_v_self = 0;
-  PyObject *__pyx_v_input_names = 0;
+static PyObject *__pyx_pw_5talib_7_ta_lib_329TYPPRICE(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_328TYPPRICE, "TYPPRICE(ndarray high, ndarray low, ndarray close)\n\nTYPPRICE(high, low, close)\n\nTypical Price (Price Transform)\n\nInputs:\n    prices: ['high', 'low', 'close']\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_329TYPPRICE = {"TYPPRICE", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_329TYPPRICE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_328TYPPRICE};
+static PyObject *__pyx_pw_5talib_7_ta_lib_329TYPPRICE(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_high = 0;
+  PyArrayObject *__pyx_v_low = 0;
+  PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[3] = {0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("set_input_names (wrapper)", 0);
+  __Pyx_RefNannySetupContext("TYPPRICE (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self,&__pyx_n_s_input_names,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);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 5131, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 5131, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 5131, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 5131, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_self)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_input_names)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("set_input_names", 1, 2, 2, 1); __PYX_ERR(1, 169, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "set_input_names") < 0)) __PYX_ERR(1, 169, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "TYPPRICE", 0) < (0)) __PYX_ERR(4, 5131, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 3; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("TYPPRICE", 1, 3, 3, i); __PYX_ERR(4, 5131, __pyx_L3_error) }
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
+    } else if (unlikely(__pyx_nargs != 3)) {
       goto __pyx_L5_argtuple_error;
     } else {
-      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 5131, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 5131, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 5131, __pyx_L3_error)
     }
-    __pyx_v_self = values[0];
-    __pyx_v_input_names = values[1];
+    __pyx_v_high = ((PyArrayObject *)values[0]);
+    __pyx_v_low = ((PyArrayObject *)values[1]);
+    __pyx_v_close = ((PyArrayObject *)values[2]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("set_input_names", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 169, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("TYPPRICE", 1, 3, 3, __pyx_nargs); __PYX_ERR(4, 5131, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.Function.set_input_names", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.TYPPRICE", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_8Function_12set_input_names(__pyx_self, __pyx_v_self, __pyx_v_input_names);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 5133, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 5133, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 5133, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_328TYPPRICE(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
-  __Pyx_RefNannyFinishContext();
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
+  __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
+  __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_12set_input_names(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_input_names) {
-  PyObject *__pyx_v_input_name = NULL;
-  PyObject *__pyx_v_price_series = NULL;
+static PyObject *__pyx_pf_5talib_7_ta_lib_328TYPPRICE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+  npy_intp __pyx_v_length;
+  int __pyx_v_begidx;
+  int __pyx_v_endidx;
+  int __pyx_v_lookback;
+  TA_RetCode __pyx_v_retCode;
+  int __pyx_v_outbegidx;
+  int __pyx_v_outnbelement;
+  PyArrayObject *__pyx_v_outreal = 0;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  PyObject *__pyx_t_2 = NULL;
-  PyObject *__pyx_t_3 = NULL;
-  Py_ssize_t __pyx_t_4;
-  PyObject *(*__pyx_t_5)(PyObject *);
-  PyObject *__pyx_t_6 = NULL;
-  PyObject *__pyx_t_7 = NULL;
-  PyObject *(*__pyx_t_8)(PyObject *);
-  __Pyx_RefNannySetupContext("set_input_names", 0);
+  npy_intp __pyx_t_2;
+  npy_int __pyx_t_3;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("TYPPRICE", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_high);
+  __Pyx_INCREF((PyObject *)__pyx_v_low);
+  __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_input_names, __pyx_n_s_items); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 173, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = NULL;
-  if (CYTHON_UNPACK_METHODS && likely(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);
-    }
-  }
-  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2);
-  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
-  if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 173, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5150, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  if (likely(PyList_CheckExact(__pyx_t_1)) || PyTuple_CheckExact(__pyx_t_1)) {
-    __pyx_t_2 = __pyx_t_1; __Pyx_INCREF(__pyx_t_2); __pyx_t_4 = 0;
-    __pyx_t_5 = NULL;
-  } else {
-    __pyx_t_4 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 173, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_2);
-    __pyx_t_5 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 173, __pyx_L1_error)
-  }
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  for (;;) {
-    if (likely(!__pyx_t_5)) {
-      if (likely(PyList_CheckExact(__pyx_t_2))) {
-        if (__pyx_t_4 >= PyList_GET_SIZE(__pyx_t_2)) break;
-        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-        __pyx_t_1 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_4); __Pyx_INCREF(__pyx_t_1); __pyx_t_4++; if (unlikely(0 < 0)) __PYX_ERR(1, 173, __pyx_L1_error)
-        #else
-        __pyx_t_1 = PySequence_ITEM(__pyx_t_2, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 173, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_1);
-        #endif
-      } else {
-        if (__pyx_t_4 >= PyTuple_GET_SIZE(__pyx_t_2)) break;
-        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-        __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_4); __Pyx_INCREF(__pyx_t_1); __pyx_t_4++; if (unlikely(0 < 0)) __PYX_ERR(1, 173, __pyx_L1_error)
-        #else
-        __pyx_t_1 = PySequence_ITEM(__pyx_t_2, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 173, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_1);
-        #endif
-      }
-    } else {
-      __pyx_t_1 = __pyx_t_5(__pyx_t_2);
-      if (unlikely(!__pyx_t_1)) {
-        PyObject* exc_type = PyErr_Occurred();
-        if (exc_type) {
-          if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
-          else __PYX_ERR(1, 173, __pyx_L1_error)
-        }
-        break;
-      }
-      __Pyx_GOTREF(__pyx_t_1);
-    }
-    if ((likely(PyTuple_CheckExact(__pyx_t_1))) || (PyList_CheckExact(__pyx_t_1))) {
-      PyObject* sequence = __pyx_t_1;
-      Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
-      if (unlikely(size != 2)) {
-        if (size > 2) __Pyx_RaiseTooManyValuesError(2);
-        else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
-        __PYX_ERR(1, 173, __pyx_L1_error)
-      }
-      #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-      if (likely(PyTuple_CheckExact(sequence))) {
-        __pyx_t_3 = PyTuple_GET_ITEM(sequence, 0); 
-        __pyx_t_6 = PyTuple_GET_ITEM(sequence, 1); 
-      } else {
-        __pyx_t_3 = PyList_GET_ITEM(sequence, 0); 
-        __pyx_t_6 = PyList_GET_ITEM(sequence, 1); 
-      }
-      __Pyx_INCREF(__pyx_t_3);
-      __Pyx_INCREF(__pyx_t_6);
-      #else
-      __pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 173, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_3);
-      __pyx_t_6 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 173, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_6);
-      #endif
-      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-    } else {
-      Py_ssize_t index = -1;
-      __pyx_t_7 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 173, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_7);
-      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-      __pyx_t_8 = Py_TYPE(__pyx_t_7)->tp_iternext;
-      index = 0; __pyx_t_3 = __pyx_t_8(__pyx_t_7); if (unlikely(!__pyx_t_3)) goto __pyx_L5_unpacking_failed;
-      __Pyx_GOTREF(__pyx_t_3);
-      index = 1; __pyx_t_6 = __pyx_t_8(__pyx_t_7); if (unlikely(!__pyx_t_6)) goto __pyx_L5_unpacking_failed;
-      __Pyx_GOTREF(__pyx_t_6);
-      if (__Pyx_IternextUnpackEndCheck(__pyx_t_8(__pyx_t_7), 2) < 0) __PYX_ERR(1, 173, __pyx_L1_error)
-      __pyx_t_8 = NULL;
-      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
-      goto __pyx_L6_unpacking_done;
-      __pyx_L5_unpacking_failed:;
-      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
-      __pyx_t_8 = NULL;
-      if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
-      __PYX_ERR(1, 173, __pyx_L1_error)
-      __pyx_L6_unpacking_done:;
-    }
-    __Pyx_XDECREF_SET(__pyx_v_input_name, __pyx_t_3);
-    __pyx_t_3 = 0;
-    __Pyx_XDECREF_SET(__pyx_v_price_series, __pyx_t_6);
-    __pyx_t_6 = 0;
+  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
 
-    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__input_names); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 174, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_1);
-    __pyx_t_6 = __Pyx_PyObject_GetItem(__pyx_t_1, __pyx_v_input_name); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 174, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_6);
-    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-    if (unlikely(PyObject_SetItem(__pyx_t_6, __pyx_n_s_price_series, __pyx_v_price_series) < 0)) __PYX_ERR(1, 174, __pyx_L1_error)
-    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5151, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
 
-    __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__info); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 175, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_6);
-    __pyx_t_1 = __Pyx_PyObject_Dict_GetItem(__pyx_t_6, __pyx_n_s_input_names); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 175, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_1);
-    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
-    if (unlikely(PyObject_SetItem(__pyx_t_1, __pyx_v_input_name, __pyx_v_price_series) < 0)) __PYX_ERR(1, 175, __pyx_L1_error)
-    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5152, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
 
-  }
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 5153, __pyx_L1_error)
+  __pyx_v_length = __pyx_t_2;
 
-  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_Function__outputs_valid, Py_False) < 0) __PYX_ERR(1, 176, __pyx_L1_error)
+  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx3(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 5154, __pyx_L1_error)
+  __pyx_v_begidx = __pyx_t_3;
 
+  __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  /* function exit code */
-  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __pyx_v_lookback = (__pyx_v_begidx + TA_TYPPRICE_Lookback());
+
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5157, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  __pyx_v_retCode = TA_TYPPRICE(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback));
+
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_TYPPRICE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5159, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF((PyObject *)__pyx_v_outreal);
+  __pyx_r = ((PyObject *)__pyx_v_outreal);
   goto __pyx_L0;
+
+
+  /* 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_6);
-  __Pyx_XDECREF(__pyx_t_7);
-  __Pyx_AddTraceback("talib._ta_lib.Function.set_input_names", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.TYPPRICE", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF(__pyx_v_input_name);
-  __Pyx_XDECREF(__pyx_v_price_series);
+  __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
+  __Pyx_XDECREF((PyObject *)__pyx_v_high);
+  __Pyx_XDECREF((PyObject *)__pyx_v_low);
+  __Pyx_XDECREF((PyObject *)__pyx_v_close);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -32647,62 +39540,238 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_12set_input_names(CYTHON_UNU
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_15get_input_arrays(PyObject *__pyx_self, PyObject *__pyx_v_self); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_8Function_14get_input_arrays[] = "\n        Returns a copy of the dict of input arrays in use.\n        ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_8Function_15get_input_arrays = {"get_input_arrays", (PyCFunction)__pyx_pw_5talib_7_ta_lib_8Function_15get_input_arrays, METH_O, __pyx_doc_5talib_7_ta_lib_8Function_14get_input_arrays};
-static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_15get_input_arrays(PyObject *__pyx_self, PyObject *__pyx_v_self) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_331ULTOSC(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_330ULTOSC, "ULTOSC(ndarray high, ndarray low, ndarray close, int timeperiod1=-0x80000000, int timeperiod2=-0x80000000, int timeperiod3=-0x80000000)\n\nULTOSC(high, low, close[, timeperiod1=?, timeperiod2=?, timeperiod3=?])\n\nUltimate Oscillator (Momentum Indicators)\n\nInputs:\n    prices: ['high', 'low', 'close']\nParameters:\n    timeperiod1: 7\n    timeperiod2: 14\n    timeperiod3: 28\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_331ULTOSC = {"ULTOSC", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_331ULTOSC, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_330ULTOSC};
+static PyObject *__pyx_pw_5talib_7_ta_lib_331ULTOSC(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_high = 0;
+  PyArrayObject *__pyx_v_low = 0;
+  PyArrayObject *__pyx_v_close = 0;
+  int __pyx_v_timeperiod1;
+  int __pyx_v_timeperiod2;
+  int __pyx_v_timeperiod3;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[6] = {0,0,0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("get_input_arrays (wrapper)", 0);
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_8Function_14get_input_arrays(__pyx_self, ((PyObject *)__pyx_v_self));
+  __Pyx_RefNannySetupContext("ULTOSC (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,&__pyx_mstate_global->__pyx_n_u_timeperiod1,&__pyx_mstate_global->__pyx_n_u_timeperiod2,&__pyx_mstate_global->__pyx_n_u_timeperiod3,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 5162, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  6:
+        values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(4, 5162, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  5:
+        values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(4, 5162, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 5162, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 5162, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 5162, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 5162, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "ULTOSC", 0) < (0)) __PYX_ERR(4, 5162, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 3; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("ULTOSC", 0, 3, 6, i); __PYX_ERR(4, 5162, __pyx_L3_error) }
+      }
+    } else {
+      switch (__pyx_nargs) {
+        case  6:
+        values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(4, 5162, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  5:
+        values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(4, 5162, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 5162, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 5162, __pyx_L3_error)
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 5162, __pyx_L3_error)
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 5162, __pyx_L3_error)
+        break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+    }
+    __pyx_v_high = ((PyArrayObject *)values[0]);
+    __pyx_v_low = ((PyArrayObject *)values[1]);
+    __pyx_v_close = ((PyArrayObject *)values[2]);
+    if (values[3]) {
+      __pyx_v_timeperiod1 = __Pyx_PyLong_As_int(values[3]); if (unlikely((__pyx_v_timeperiod1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 5164, __pyx_L3_error)
+    } else {
+      __pyx_v_timeperiod1 = ((int)((int)-2147483648));
+    }
+    if (values[4]) {
+      __pyx_v_timeperiod2 = __Pyx_PyLong_As_int(values[4]); if (unlikely((__pyx_v_timeperiod2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 5164, __pyx_L3_error)
+    } else {
+      __pyx_v_timeperiod2 = ((int)((int)-2147483648));
+    }
+    if (values[5]) {
+      __pyx_v_timeperiod3 = __Pyx_PyLong_As_int(values[5]); if (unlikely((__pyx_v_timeperiod3 == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 5164, __pyx_L3_error)
+    } else {
+      __pyx_v_timeperiod3 = ((int)((int)-2147483648));
+    }
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("ULTOSC", 0, 3, 6, __pyx_nargs); __PYX_ERR(4, 5162, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.ULTOSC", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 5164, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 5164, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 5164, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_330ULTOSC(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_timeperiod1, __pyx_v_timeperiod2, __pyx_v_timeperiod3);
 
   /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
+  __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_14get_input_arrays(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_330ULTOSC(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod1, int __pyx_v_timeperiod2, int __pyx_v_timeperiod3) {
+  npy_intp __pyx_v_length;
+  int __pyx_v_begidx;
+  int __pyx_v_endidx;
+  int __pyx_v_lookback;
+  TA_RetCode __pyx_v_retCode;
+  int __pyx_v_outbegidx;
+  int __pyx_v_outnbelement;
+  PyArrayObject *__pyx_v_outreal = 0;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  PyObject *__pyx_t_2 = NULL;
-  PyObject *__pyx_t_3 = NULL;
-  __Pyx_RefNannySetupContext("get_input_arrays", 0);
+  npy_intp __pyx_t_2;
+  npy_int __pyx_t_3;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("ULTOSC", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_high);
+  __Pyx_INCREF((PyObject *)__pyx_v_low);
+  __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __Pyx_XDECREF(__pyx_r);
-  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__input_arrays); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 184, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_copy); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 184, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __pyx_t_2 = NULL;
-  if (CYTHON_UNPACK_METHODS && likely(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_1 = (__pyx_t_2) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2) : __Pyx_PyObject_CallNoArg(__pyx_t_3);
-  __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
-  if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 184, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5185, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __pyx_r = __pyx_t_1;
+  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
+
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5186, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
+
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5187, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
+
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 5188, __pyx_L1_error)
+  __pyx_v_length = __pyx_t_2;
+
+  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx3(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 5189, __pyx_L1_error)
+  __pyx_v_begidx = __pyx_t_3;
+
+  __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
+
+  __pyx_v_lookback = (__pyx_v_begidx + TA_ULTOSC_Lookback(__pyx_v_timeperiod1, __pyx_v_timeperiod2, __pyx_v_timeperiod3));
+
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5192, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
   __pyx_t_1 = 0;
+
+  __pyx_v_retCode = TA_ULTOSC(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), __pyx_v_timeperiod1, __pyx_v_timeperiod2, __pyx_v_timeperiod3, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback));
+
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_ULTOSC, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5194, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF((PyObject *)__pyx_v_outreal);
+  __pyx_r = ((PyObject *)__pyx_v_outreal);
   goto __pyx_L0;
 
 
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_XDECREF(__pyx_t_2);
-  __Pyx_XDECREF(__pyx_t_3);
-  __Pyx_AddTraceback("talib._ta_lib.Function.get_input_arrays", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.ULTOSC", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
+  __Pyx_XDECREF((PyObject *)__pyx_v_high);
+  __Pyx_XDECREF((PyObject *)__pyx_v_low);
+  __Pyx_XDECREF((PyObject *)__pyx_v_close);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -32710,233 +39779,190 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_14get_input_arrays(CYTHON_UN
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_17set_input_arrays(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_8Function_16set_input_arrays[] = "\n        Sets the dict of input_arrays to use. Returns True/False for\n        subclasses:\n\n        If input_arrays is a dict with the keys open, high, low, close and\n        volume, it is assigned as the input_array to use and this function\n        returns True, returning False otherwise. If you implement your own\n        data type and wish to subclass Function, you should wrap this function\n        with an if-statement:\n\n        class CustomFunction(Function):\n            def __init__(self, function_name):\n                Function.__init__(self, function_name)\n\n            def set_input_arrays(self, input_data):\n                if Function.set_input_arrays(self, input_data):\n                    return True\n                elif isinstance(input_data, some_module.CustomDataType):\n                    input_arrays = Function.get_input_arrays(self)\n                    # convert input_data to input_arrays and then call the super\n                    Function.set_input_arrays(self, input_arrays)\n                    return True\n                return False\n        ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_8Function_17set_input_arrays = {"set_input_arrays", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_8Function_17set_input_arrays, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_8Function_16set_input_arrays};
-static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_17set_input_arrays(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyObject *__pyx_v_self = 0;
-  PyObject *__pyx_v_input_arrays = 0;
+static PyObject *__pyx_pw_5talib_7_ta_lib_333VAR(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_332VAR, "VAR(ndarray real, int timeperiod=-0x80000000, double nbdev=-4e37)\n\nVAR(real[, timeperiod=?, nbdev=?])\n\nVariance (Statistic Functions)\n\nInputs:\n    real: (any ndarray)\nParameters:\n    timeperiod: 5\n    nbdev: 1.0\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_333VAR = {"VAR", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_333VAR, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_332VAR};
+static PyObject *__pyx_pw_5talib_7_ta_lib_333VAR(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_real = 0;
+  int __pyx_v_timeperiod;
+  double __pyx_v_nbdev;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[3] = {0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("set_input_arrays (wrapper)", 0);
+  __Pyx_RefNannySetupContext("VAR (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self,&__pyx_n_s_input_arrays,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);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,&__pyx_mstate_global->__pyx_n_u_nbdev,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 5197, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 5197, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 5197, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 5197, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_self)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "VAR", 0) < (0)) __PYX_ERR(4, 5197, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("VAR", 0, 1, 3, i); __PYX_ERR(4, 5197, __pyx_L3_error) }
+      }
+    } else {
+      switch (__pyx_nargs) {
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 5197, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 5197, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_input_arrays)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("set_input_arrays", 1, 2, 2, 1); __PYX_ERR(1, 186, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "set_input_arrays") < 0)) __PYX_ERR(1, 186, __pyx_L3_error)
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 5197, __pyx_L3_error)
+        break;
+        default: goto __pyx_L5_argtuple_error;
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
-      goto __pyx_L5_argtuple_error;
+    }
+    __pyx_v_real = ((PyArrayObject *)values[0]);
+    if (values[1]) {
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 5199, __pyx_L3_error)
     } else {
-      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
+    }
+    if (values[2]) {
+      __pyx_v_nbdev = __Pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_nbdev == (double)-1) && PyErr_Occurred())) __PYX_ERR(4, 5199, __pyx_L3_error)
+    } else {
+      __pyx_v_nbdev = ((double)((double)-4e37));
     }
-    __pyx_v_self = values[0];
-    __pyx_v_input_arrays = values[1];
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("set_input_arrays", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 186, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("VAR", 0, 1, 3, __pyx_nargs); __PYX_ERR(4, 5197, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.Function.set_input_arrays", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.VAR", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_8Function_16set_input_arrays(__pyx_self, __pyx_v_self, __pyx_v_input_arrays);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 5199, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_332VAR(__pyx_self, __pyx_v_real, __pyx_v_timeperiod, __pyx_v_nbdev);
 
   /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
+  __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_16set_input_arrays(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_input_arrays) {
-  PyObject *__pyx_v_missing_keys = NULL;
-  PyObject *__pyx_v_key = NULL;
+static PyObject *__pyx_pf_5talib_7_ta_lib_332VAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod, double __pyx_v_nbdev) {
+  npy_intp __pyx_v_length;
+  int __pyx_v_begidx;
+  int __pyx_v_endidx;
+  int __pyx_v_lookback;
+  TA_RetCode __pyx_v_retCode;
+  int __pyx_v_outbegidx;
+  int __pyx_v_outnbelement;
+  PyArrayObject *__pyx_v_outreal = 0;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  int __pyx_t_2;
-  int __pyx_t_3;
-  PyObject *__pyx_t_4 = NULL;
-  PyObject *__pyx_t_5 = NULL;
-  Py_ssize_t __pyx_t_6;
-  PyObject *(*__pyx_t_7)(PyObject *);
-  int __pyx_t_8;
-  __Pyx_RefNannySetupContext("set_input_arrays", 0);
+  npy_int __pyx_t_2;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("VAR", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_INPUT_ARRAYS_TYPES); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 211, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5219, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = PyObject_IsInstance(__pyx_v_input_arrays, __pyx_t_1); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(1, 211, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_3 = (__pyx_t_2 != 0);
-  if (__pyx_t_3) {
-
-    __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 212, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_1);
-    __pyx_v_missing_keys = ((PyObject*)__pyx_t_1);
-    __pyx_t_1 = 0;
-
-    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__input_price_series_na); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 213, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_4);
-    __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);
-      }
-    }
-    __pyx_t_1 = (__pyx_t_5) ? __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5) : __Pyx_PyObject_CallNoArg(__pyx_t_4);
-    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
-    if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 213, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_1);
-    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-    if (likely(PyList_CheckExact(__pyx_t_1)) || PyTuple_CheckExact(__pyx_t_1)) {
-      __pyx_t_4 = __pyx_t_1; __Pyx_INCREF(__pyx_t_4); __pyx_t_6 = 0;
-      __pyx_t_7 = NULL;
-    } else {
-      __pyx_t_6 = -1; __pyx_t_4 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 213, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_4);
-      __pyx_t_7 = Py_TYPE(__pyx_t_4)->tp_iternext; if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 213, __pyx_L1_error)
-    }
-    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-    for (;;) {
-      if (likely(!__pyx_t_7)) {
-        if (likely(PyList_CheckExact(__pyx_t_4))) {
-          if (__pyx_t_6 >= PyList_GET_SIZE(__pyx_t_4)) break;
-          #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-          __pyx_t_1 = PyList_GET_ITEM(__pyx_t_4, __pyx_t_6); __Pyx_INCREF(__pyx_t_1); __pyx_t_6++; if (unlikely(0 < 0)) __PYX_ERR(1, 213, __pyx_L1_error)
-          #else
-          __pyx_t_1 = PySequence_ITEM(__pyx_t_4, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 213, __pyx_L1_error)
-          __Pyx_GOTREF(__pyx_t_1);
-          #endif
-        } else {
-          if (__pyx_t_6 >= PyTuple_GET_SIZE(__pyx_t_4)) break;
-          #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-          __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_4, __pyx_t_6); __Pyx_INCREF(__pyx_t_1); __pyx_t_6++; if (unlikely(0 < 0)) __PYX_ERR(1, 213, __pyx_L1_error)
-          #else
-          __pyx_t_1 = PySequence_ITEM(__pyx_t_4, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 213, __pyx_L1_error)
-          __Pyx_GOTREF(__pyx_t_1);
-          #endif
-        }
-      } else {
-        __pyx_t_1 = __pyx_t_7(__pyx_t_4);
-        if (unlikely(!__pyx_t_1)) {
-          PyObject* exc_type = PyErr_Occurred();
-          if (exc_type) {
-            if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
-            else __PYX_ERR(1, 213, __pyx_L1_error)
-          }
-          break;
-        }
-        __Pyx_GOTREF(__pyx_t_1);
-      }
-      __Pyx_XDECREF_SET(__pyx_v_key, __pyx_t_1);
-      __pyx_t_1 = 0;
-
-      __pyx_t_3 = (__Pyx_PySequence_ContainsTF(__pyx_v_key, __pyx_v_input_arrays, Py_NE)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(1, 214, __pyx_L1_error)
-      __pyx_t_2 = (__pyx_t_3 != 0);
-      if (__pyx_t_2) {
-
-        __pyx_t_8 = __Pyx_PyList_Append(__pyx_v_missing_keys, __pyx_v_key); if (unlikely(__pyx_t_8 == ((int)-1))) __PYX_ERR(1, 215, __pyx_L1_error)
-
-      }
-
-    }
-    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-
-    __pyx_t_6 = PyList_GET_SIZE(__pyx_v_missing_keys); if (unlikely(__pyx_t_6 == ((Py_ssize_t)-1))) __PYX_ERR(1, 216, __pyx_L1_error)
-    __pyx_t_2 = ((__pyx_t_6 == 0) != 0);
-    if (likely(__pyx_t_2)) {
-
-      if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_Function__input_arrays, __pyx_v_input_arrays) < 0) __PYX_ERR(1, 217, __pyx_L1_error)
-
-      if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_Function__outputs_valid, Py_False) < 0) __PYX_ERR(1, 218, __pyx_L1_error)
-
-      __Pyx_XDECREF(__pyx_r);
-      __Pyx_INCREF(Py_True);
-      __pyx_r = Py_True;
-      goto __pyx_L0;
+  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
 
-    }
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
-    /*else*/ {
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 5221, __pyx_L1_error)
+  __pyx_v_begidx = __pyx_t_2;
 
-      __pyx_t_6 = PyList_GET_SIZE(__pyx_v_missing_keys); if (unlikely(__pyx_t_6 == ((Py_ssize_t)-1))) __PYX_ERR(1, 222, __pyx_L1_error)
-      if (((__pyx_t_6 > 1) != 0)) {
-        __Pyx_INCREF(__pyx_n_s_s);
-        __pyx_t_4 = __pyx_n_s_s;
-      } else {
-        __Pyx_INCREF(__pyx_kp_s__5);
-        __pyx_t_4 = __pyx_kp_s__5;
-      }
+  __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-      __pyx_t_1 = __Pyx_PyString_Join(__pyx_kp_s__6, __pyx_v_missing_keys); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 224, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_lookback = (__pyx_v_begidx + TA_VAR_Lookback(__pyx_v_timeperiod, __pyx_v_nbdev));
 
-      __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 222, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_5);
-      __Pyx_GIVEREF(__pyx_t_4);
-      PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4);
-      __Pyx_GIVEREF(__pyx_t_1);
-      PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_1);
-      __pyx_t_4 = 0;
-      __pyx_t_1 = 0;
-      __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_input_arrays_parameter_missing_r, __pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 222, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_1);
-      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5224, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
+  __pyx_t_1 = 0;
 
-      __pyx_t_5 = __Pyx_PyObject_CallOneArg(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 221, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_5);
-      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-      __Pyx_Raise(__pyx_t_5, 0, 0, 0);
-      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-      __PYX_ERR(1, 221, __pyx_L1_error)
-    }
+  __pyx_v_retCode = TA_VAR(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), __pyx_v_timeperiod, __pyx_v_nbdev, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback));
 
-  }
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_VAR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5226, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(Py_False);
-  __pyx_r = Py_False;
+  __Pyx_INCREF((PyObject *)__pyx_v_outreal);
+  __pyx_r = ((PyObject *)__pyx_v_outreal);
   goto __pyx_L0;
 
 
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_XDECREF(__pyx_t_4);
-  __Pyx_XDECREF(__pyx_t_5);
-  __Pyx_AddTraceback("talib._ta_lib.Function.set_input_arrays", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.VAR", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF(__pyx_v_missing_keys);
-  __Pyx_XDECREF(__pyx_v_key);
+  __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
+  __Pyx_XDECREF((PyObject *)__pyx_v_real);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -32944,138 +39970,193 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_16set_input_arrays(CYTHON_UN
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_19get_parameters(PyObject *__pyx_self, PyObject *__pyx_v_self); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_8Function_18get_parameters[] = "\n        Returns the function's optional parameters and their default values.\n        ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_8Function_19get_parameters = {"get_parameters", (PyCFunction)__pyx_pw_5talib_7_ta_lib_8Function_19get_parameters, METH_O, __pyx_doc_5talib_7_ta_lib_8Function_18get_parameters};
-static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_19get_parameters(PyObject *__pyx_self, PyObject *__pyx_v_self) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_335WCLPRICE(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_334WCLPRICE, "WCLPRICE(ndarray high, ndarray low, ndarray close)\n\nWCLPRICE(high, low, close)\n\nWeighted Close Price (Price Transform)\n\nInputs:\n    prices: ['high', 'low', 'close']\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_335WCLPRICE = {"WCLPRICE", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_335WCLPRICE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_334WCLPRICE};
+static PyObject *__pyx_pw_5talib_7_ta_lib_335WCLPRICE(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_high = 0;
+  PyArrayObject *__pyx_v_low = 0;
+  PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[3] = {0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("get_parameters (wrapper)", 0);
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_8Function_18get_parameters(__pyx_self, ((PyObject *)__pyx_v_self));
+  __Pyx_RefNannySetupContext("WCLPRICE (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 5229, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 5229, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 5229, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 5229, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "WCLPRICE", 0) < (0)) __PYX_ERR(4, 5229, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 3; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("WCLPRICE", 1, 3, 3, i); __PYX_ERR(4, 5229, __pyx_L3_error) }
+      }
+    } else if (unlikely(__pyx_nargs != 3)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 5229, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 5229, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 5229, __pyx_L3_error)
+    }
+    __pyx_v_high = ((PyArrayObject *)values[0]);
+    __pyx_v_low = ((PyArrayObject *)values[1]);
+    __pyx_v_close = ((PyArrayObject *)values[2]);
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("WCLPRICE", 1, 3, 3, __pyx_nargs); __PYX_ERR(4, 5229, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.WCLPRICE", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 5231, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 5231, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 5231, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_334WCLPRICE(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
+  __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_18get_parameters(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
-  PyObject *__pyx_v_ret = NULL;
-  PyObject *__pyx_v_opt_input = NULL;
-  PyObject *__pyx_r = NULL;
-  __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
-  PyObject *__pyx_t_2 = NULL;
-  PyObject *__pyx_t_3 = NULL;
-  Py_ssize_t __pyx_t_4;
-  PyObject *(*__pyx_t_5)(PyObject *);
-  PyObject *__pyx_t_6 = NULL;
-  __Pyx_RefNannySetupContext("get_parameters", 0);
+static PyObject *__pyx_pf_5talib_7_ta_lib_334WCLPRICE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+  npy_intp __pyx_v_length;
+  int __pyx_v_begidx;
+  int __pyx_v_endidx;
+  int __pyx_v_lookback;
+  TA_RetCode __pyx_v_retCode;
+  int __pyx_v_outbegidx;
+  int __pyx_v_outnbelement;
+  PyArrayObject *__pyx_v_outreal = 0;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  npy_intp __pyx_t_2;
+  npy_int __pyx_t_3;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("WCLPRICE", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_high);
+  __Pyx_INCREF((PyObject *)__pyx_v_low);
+  __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_OrderedDict); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 233, __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);
-    }
-  }
-  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2);
-  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
-  if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 233, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5248, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __pyx_v_ret = __pyx_t_1;
+  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__opt_inputs); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 234, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5249, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  if (likely(PyList_CheckExact(__pyx_t_1)) || PyTuple_CheckExact(__pyx_t_1)) {
-    __pyx_t_2 = __pyx_t_1; __Pyx_INCREF(__pyx_t_2); __pyx_t_4 = 0;
-    __pyx_t_5 = NULL;
-  } else {
-    __pyx_t_4 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 234, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_2);
-    __pyx_t_5 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 234, __pyx_L1_error)
-  }
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  for (;;) {
-    if (likely(!__pyx_t_5)) {
-      if (likely(PyList_CheckExact(__pyx_t_2))) {
-        if (__pyx_t_4 >= PyList_GET_SIZE(__pyx_t_2)) break;
-        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-        __pyx_t_1 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_4); __Pyx_INCREF(__pyx_t_1); __pyx_t_4++; if (unlikely(0 < 0)) __PYX_ERR(1, 234, __pyx_L1_error)
-        #else
-        __pyx_t_1 = PySequence_ITEM(__pyx_t_2, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 234, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_1);
-        #endif
-      } else {
-        if (__pyx_t_4 >= PyTuple_GET_SIZE(__pyx_t_2)) break;
-        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-        __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_4); __Pyx_INCREF(__pyx_t_1); __pyx_t_4++; if (unlikely(0 < 0)) __PYX_ERR(1, 234, __pyx_L1_error)
-        #else
-        __pyx_t_1 = PySequence_ITEM(__pyx_t_2, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 234, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_1);
-        #endif
-      }
-    } else {
-      __pyx_t_1 = __pyx_t_5(__pyx_t_2);
-      if (unlikely(!__pyx_t_1)) {
-        PyObject* exc_type = PyErr_Occurred();
-        if (exc_type) {
-          if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
-          else __PYX_ERR(1, 234, __pyx_L1_error)
-        }
-        break;
-      }
-      __Pyx_GOTREF(__pyx_t_1);
-    }
-    __Pyx_XDECREF_SET(__pyx_v_opt_input, __pyx_t_1);
-    __pyx_t_1 = 0;
+  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
 
-    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__get_opt_input_value); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 235, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_3);
-    __pyx_t_6 = NULL;
-    if (CYTHON_UNPACK_METHODS && likely(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_1 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_6, __pyx_v_opt_input) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_opt_input);
-    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
-    if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 235, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_1);
-    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-    if (unlikely(PyObject_SetItem(__pyx_v_ret, __pyx_v_opt_input, __pyx_t_1) < 0)) __PYX_ERR(1, 235, __pyx_L1_error)
-    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5250, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
 
-  }
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 5251, __pyx_L1_error)
+  __pyx_v_length = __pyx_t_2;
+
+  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx3(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 5252, __pyx_L1_error)
+  __pyx_v_begidx = __pyx_t_3;
+
+  __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
+
+  __pyx_v_lookback = (__pyx_v_begidx + TA_WCLPRICE_Lookback());
+
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5255, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  __pyx_v_retCode = TA_WCLPRICE(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback));
+
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_WCLPRICE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5257, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(__pyx_v_ret);
-  __pyx_r = __pyx_v_ret;
+  __Pyx_INCREF((PyObject *)__pyx_v_outreal);
+  __pyx_r = ((PyObject *)__pyx_v_outreal);
   goto __pyx_L0;
 
 
   /* 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_6);
-  __Pyx_AddTraceback("talib._ta_lib.Function.get_parameters", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.WCLPRICE", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF(__pyx_v_ret);
-  __Pyx_XDECREF(__pyx_v_opt_input);
+  __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
+  __Pyx_XDECREF((PyObject *)__pyx_v_high);
+  __Pyx_XDECREF((PyObject *)__pyx_v_low);
+  __Pyx_XDECREF((PyObject *)__pyx_v_close);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -33083,328 +40164,210 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_18get_parameters(CYTHON_UNUS
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_21set_parameters(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_8Function_20set_parameters[] = "\n        Sets the function parameter values.\n        ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_8Function_21set_parameters = {"set_parameters", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_8Function_21set_parameters, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_8Function_20set_parameters};
-static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_21set_parameters(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyObject *__pyx_v_self = 0;
-  PyObject *__pyx_v_parameters = 0;
-  PyObject *__pyx_v_kwargs = 0;
+static PyObject *__pyx_pw_5talib_7_ta_lib_337WILLR(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_336WILLR, "WILLR(ndarray high, ndarray low, ndarray close, int timeperiod=-0x80000000)\n\nWILLR(high, low, close[, timeperiod=?])\n\nWilliams' %R (Momentum Indicators)\n\nInputs:\n    prices: ['high', 'low', 'close']\nParameters:\n    timeperiod: 14\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_337WILLR = {"WILLR", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_337WILLR, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_336WILLR};
+static PyObject *__pyx_pw_5talib_7_ta_lib_337WILLR(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_high = 0;
+  PyArrayObject *__pyx_v_low = 0;
+  PyArrayObject *__pyx_v_close = 0;
+  int __pyx_v_timeperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("set_parameters (wrapper)", 0);
-  __pyx_v_kwargs = PyDict_New(); if (unlikely(!__pyx_v_kwargs)) return NULL;
-  __Pyx_GOTREF(__pyx_v_kwargs);
+  __Pyx_RefNannySetupContext("WILLR (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self,&__pyx_n_s_parameters,0};
-    PyObject* values[2] = {0,0};
-    values[1] = ((PyObject *)((PyObject *)Py_None));
-    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);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,&__pyx_mstate_global->__pyx_n_u_timeperiod,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 5260, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 5260, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 5260, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  0: break;
-        default: goto __pyx_L5_argtuple_error;
-      }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_self)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 5260, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  1:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_parameters);
-          if (value) { values[1] = value; kw_args--; }
-        }
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 5260, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
       }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, __pyx_v_kwargs, values, pos_args, "set_parameters") < 0)) __PYX_ERR(1, 238, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "WILLR", 0) < (0)) __PYX_ERR(4, 5260, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 3; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("WILLR", 0, 3, 4, i); __PYX_ERR(4, 5260, __pyx_L3_error) }
       }
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(4, 5260, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(4, 5260, __pyx_L3_error)
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 5260, __pyx_L3_error)
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 5260, __pyx_L3_error)
         break;
         default: goto __pyx_L5_argtuple_error;
       }
     }
-    __pyx_v_self = values[0];
-    __pyx_v_parameters = values[1];
+    __pyx_v_high = ((PyArrayObject *)values[0]);
+    __pyx_v_low = ((PyArrayObject *)values[1]);
+    __pyx_v_close = ((PyArrayObject *)values[2]);
+    if (values[3]) {
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[3]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 5262, __pyx_L3_error)
+    } else {
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
+    }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("set_parameters", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 238, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("WILLR", 0, 3, 4, __pyx_nargs); __PYX_ERR(4, 5260, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_DECREF(__pyx_v_kwargs); __pyx_v_kwargs = 0;
-  __Pyx_AddTraceback("talib._ta_lib.Function.set_parameters", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.WILLR", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_8Function_20set_parameters(__pyx_self, __pyx_v_self, __pyx_v_parameters, __pyx_v_kwargs);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(4, 5262, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(4, 5262, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(4, 5262, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_336WILLR(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_timeperiod);
 
   /* function exit code */
-  __Pyx_XDECREF(__pyx_v_kwargs);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
+  __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_20set_parameters(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_parameters, PyObject *__pyx_v_kwargs) {
-  PyObject *__pyx_v_param = NULL;
-  PyObject *__pyx_v_value = NULL;
+static PyObject *__pyx_pf_5talib_7_ta_lib_336WILLR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod) {
+  npy_intp __pyx_v_length;
+  int __pyx_v_begidx;
+  int __pyx_v_endidx;
+  int __pyx_v_lookback;
+  TA_RetCode __pyx_v_retCode;
+  int __pyx_v_outbegidx;
+  int __pyx_v_outnbelement;
+  PyArrayObject *__pyx_v_outreal = 0;
   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;
-  Py_ssize_t __pyx_t_5;
-  PyObject *(*__pyx_t_6)(PyObject *);
-  PyObject *__pyx_t_7 = NULL;
-  PyObject *__pyx_t_8 = NULL;
-  PyObject *(*__pyx_t_9)(PyObject *);
-  int __pyx_t_10;
-  __Pyx_RefNannySetupContext("set_parameters", 0);
-  __Pyx_INCREF(__pyx_v_parameters);
+  npy_intp __pyx_t_2;
+  npy_int __pyx_t_3;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("WILLR", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_high);
+  __Pyx_INCREF((PyObject *)__pyx_v_low);
+  __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_parameters); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(1, 242, __pyx_L1_error)
-  if (!__pyx_t_2) {
-  } else {
-    __Pyx_INCREF(__pyx_v_parameters);
-    __pyx_t_1 = __pyx_v_parameters;
-    goto __pyx_L3_bool_binop_done;
-  }
-  __pyx_t_3 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 242, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __Pyx_INCREF(__pyx_t_3);
-  __pyx_t_1 = __pyx_t_3;
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __pyx_L3_bool_binop_done:;
-  __Pyx_DECREF_SET(__pyx_v_parameters, __pyx_t_1);
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5281, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_parameters, __pyx_n_s_update); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 243, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = NULL;
-  if (CYTHON_UNPACK_METHODS && likely(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_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_v_kwargs) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_kwargs);
-  __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
-  if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 243, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5282, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
 
-  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_parameters, __pyx_n_s_items); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 244, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = NULL;
-  if (CYTHON_UNPACK_METHODS && likely(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_1 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_3);
-  __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
-  if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 244, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5283, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  if (likely(PyList_CheckExact(__pyx_t_1)) || PyTuple_CheckExact(__pyx_t_1)) {
-    __pyx_t_3 = __pyx_t_1; __Pyx_INCREF(__pyx_t_3); __pyx_t_5 = 0;
-    __pyx_t_6 = NULL;
-  } else {
-    __pyx_t_5 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 244, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_3);
-    __pyx_t_6 = Py_TYPE(__pyx_t_3)->tp_iternext; if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 244, __pyx_L1_error)
-  }
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  for (;;) {
-    if (likely(!__pyx_t_6)) {
-      if (likely(PyList_CheckExact(__pyx_t_3))) {
-        if (__pyx_t_5 >= PyList_GET_SIZE(__pyx_t_3)) break;
-        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-        __pyx_t_1 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_5); __Pyx_INCREF(__pyx_t_1); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(1, 244, __pyx_L1_error)
-        #else
-        __pyx_t_1 = PySequence_ITEM(__pyx_t_3, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 244, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_1);
-        #endif
-      } else {
-        if (__pyx_t_5 >= PyTuple_GET_SIZE(__pyx_t_3)) break;
-        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-        __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_5); __Pyx_INCREF(__pyx_t_1); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(1, 244, __pyx_L1_error)
-        #else
-        __pyx_t_1 = PySequence_ITEM(__pyx_t_3, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 244, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_1);
-        #endif
-      }
-    } else {
-      __pyx_t_1 = __pyx_t_6(__pyx_t_3);
-      if (unlikely(!__pyx_t_1)) {
-        PyObject* exc_type = PyErr_Occurred();
-        if (exc_type) {
-          if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
-          else __PYX_ERR(1, 244, __pyx_L1_error)
-        }
-        break;
-      }
-      __Pyx_GOTREF(__pyx_t_1);
-    }
-    if ((likely(PyTuple_CheckExact(__pyx_t_1))) || (PyList_CheckExact(__pyx_t_1))) {
-      PyObject* sequence = __pyx_t_1;
-      Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
-      if (unlikely(size != 2)) {
-        if (size > 2) __Pyx_RaiseTooManyValuesError(2);
-        else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
-        __PYX_ERR(1, 244, __pyx_L1_error)
-      }
-      #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-      if (likely(PyTuple_CheckExact(sequence))) {
-        __pyx_t_4 = PyTuple_GET_ITEM(sequence, 0); 
-        __pyx_t_7 = PyTuple_GET_ITEM(sequence, 1); 
-      } else {
-        __pyx_t_4 = PyList_GET_ITEM(sequence, 0); 
-        __pyx_t_7 = PyList_GET_ITEM(sequence, 1); 
-      }
-      __Pyx_INCREF(__pyx_t_4);
-      __Pyx_INCREF(__pyx_t_7);
-      #else
-      __pyx_t_4 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 244, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_4);
-      __pyx_t_7 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 244, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_7);
-      #endif
-      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-    } else {
-      Py_ssize_t index = -1;
-      __pyx_t_8 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 244, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_8);
-      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-      __pyx_t_9 = Py_TYPE(__pyx_t_8)->tp_iternext;
-      index = 0; __pyx_t_4 = __pyx_t_9(__pyx_t_8); if (unlikely(!__pyx_t_4)) goto __pyx_L7_unpacking_failed;
-      __Pyx_GOTREF(__pyx_t_4);
-      index = 1; __pyx_t_7 = __pyx_t_9(__pyx_t_8); if (unlikely(!__pyx_t_7)) goto __pyx_L7_unpacking_failed;
-      __Pyx_GOTREF(__pyx_t_7);
-      if (__Pyx_IternextUnpackEndCheck(__pyx_t_9(__pyx_t_8), 2) < 0) __PYX_ERR(1, 244, __pyx_L1_error)
-      __pyx_t_9 = NULL;
-      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
-      goto __pyx_L8_unpacking_done;
-      __pyx_L7_unpacking_failed:;
-      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
-      __pyx_t_9 = NULL;
-      if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
-      __PYX_ERR(1, 244, __pyx_L1_error)
-      __pyx_L8_unpacking_done:;
-    }
-    __Pyx_XDECREF_SET(__pyx_v_param, __pyx_t_4);
-    __pyx_t_4 = 0;
-    __Pyx_XDECREF_SET(__pyx_v_value, __pyx_t_7);
-    __pyx_t_7 = 0;
+  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
 
-    __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__check_opt_input_value); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 245, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_7);
-    __pyx_t_4 = NULL;
-    __pyx_t_10 = 0;
-    if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_7))) {
-      __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_7);
-      if (likely(__pyx_t_4)) {
-        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7);
-        __Pyx_INCREF(__pyx_t_4);
-        __Pyx_INCREF(function);
-        __Pyx_DECREF_SET(__pyx_t_7, function);
-        __pyx_t_10 = 1;
-      }
-    }
-    #if CYTHON_FAST_PYCALL
-    if (PyFunction_Check(__pyx_t_7)) {
-      PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_v_param, __pyx_v_value};
-      __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_7, __pyx_temp+1-__pyx_t_10, 2+__pyx_t_10); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 245, __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_7)) {
-      PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_v_param, __pyx_v_value};
-      __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_7, __pyx_temp+1-__pyx_t_10, 2+__pyx_t_10); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 245, __pyx_L1_error)
-      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
-      __Pyx_GOTREF(__pyx_t_1);
-    } else
-    #endif
-    {
-      __pyx_t_8 = PyTuple_New(2+__pyx_t_10); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 245, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_8);
-      if (__pyx_t_4) {
-        __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_4); __pyx_t_4 = NULL;
-      }
-      __Pyx_INCREF(__pyx_v_param);
-      __Pyx_GIVEREF(__pyx_v_param);
-      PyTuple_SET_ITEM(__pyx_t_8, 0+__pyx_t_10, __pyx_v_param);
-      __Pyx_INCREF(__pyx_v_value);
-      __Pyx_GIVEREF(__pyx_v_value);
-      PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_10, __pyx_v_value);
-      __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_8, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 245, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_1);
-      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
-    }
-    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
-    __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(1, 245, __pyx_L1_error)
-    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-    if (__pyx_t_2) {
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(4, 5284, __pyx_L1_error)
+  __pyx_v_length = __pyx_t_2;
 
-      __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__opt_inputs); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 246, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_1);
-      __pyx_t_7 = __Pyx_PyObject_GetItem(__pyx_t_1, __pyx_v_param); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 246, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_7);
-      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-      if (unlikely(PyObject_SetItem(__pyx_t_7, __pyx_n_s_value, __pyx_v_value) < 0)) __PYX_ERR(1, 246, __pyx_L1_error)
-      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx3(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 5285, __pyx_L1_error)
+  __pyx_v_begidx = __pyx_t_3;
 
-    }
+  __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-  }
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_v_lookback = (__pyx_v_begidx + TA_WILLR_Lookback(__pyx_v_timeperiod));
 
-  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_Function__outputs_valid, Py_False) < 0) __PYX_ERR(1, 247, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5288, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
+  __pyx_t_1 = 0;
 
-  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_parameters); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 248, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__info); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 248, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_7);
-  if (unlikely(PyObject_SetItem(__pyx_t_7, __pyx_n_s_parameters, __pyx_t_3) < 0)) __PYX_ERR(1, 248, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_v_retCode = TA_WILLR(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)) + __pyx_v_begidx), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback));
 
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_WILLR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5290, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
-  /* function exit code */
-  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF((PyObject *)__pyx_v_outreal);
+  __pyx_r = ((PyObject *)__pyx_v_outreal);
   goto __pyx_L0;
+
+
+  /* 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_7);
-  __Pyx_XDECREF(__pyx_t_8);
-  __Pyx_AddTraceback("talib._ta_lib.Function.set_parameters", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.WILLR", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF(__pyx_v_param);
-  __Pyx_XDECREF(__pyx_v_value);
-  __Pyx_XDECREF(__pyx_v_parameters);
+  __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
+  __Pyx_XDECREF((PyObject *)__pyx_v_high);
+  __Pyx_XDECREF((PyObject *)__pyx_v_low);
+  __Pyx_XDECREF((PyObject *)__pyx_v_close);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -33412,469 +40375,306 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_20set_parameters(CYTHON_UNUS
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_23set_function_args(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_8Function_22set_function_args[] = "\n        optional args:[input_arrays,] [parameter_args,] [input_price_series_kwargs,] [parameter_kwargs]\n        ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_8Function_23set_function_args = {"set_function_args", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_8Function_23set_function_args, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_8Function_22set_function_args};
-static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_23set_function_args(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyObject *__pyx_v_self = 0;
-  PyObject *__pyx_v_args = 0;
-  PyObject *__pyx_v_kwargs = 0;
+static PyObject *__pyx_pw_5talib_7_ta_lib_339WMA(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_338WMA, "WMA(ndarray real, int timeperiod=-0x80000000)\n\nWMA(real[, timeperiod=?])\n\nWeighted Moving Average (Overlap Studies)\n\nInputs:\n    real: (any ndarray)\nParameters:\n    timeperiod: 30\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_339WMA = {"WMA", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_339WMA, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_338WMA};
+static PyObject *__pyx_pw_5talib_7_ta_lib_339WMA(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_real = 0;
+  int __pyx_v_timeperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("set_function_args (wrapper)", 0);
-  __pyx_v_kwargs = PyDict_New(); if (unlikely(!__pyx_v_kwargs)) return NULL;
-  __Pyx_GOTREF(__pyx_v_kwargs);
-  if (PyTuple_GET_SIZE(__pyx_args) > 1) {
-    __pyx_v_args = PyTuple_GetSlice(__pyx_args, 1, PyTuple_GET_SIZE(__pyx_args));
-    if (unlikely(!__pyx_v_args)) {
-      __Pyx_DECREF(__pyx_v_kwargs); __pyx_v_kwargs = 0;
-      __Pyx_RefNannyFinishContext();
-      return NULL;
-    }
-    __Pyx_GOTREF(__pyx_v_args);
-  } else {
-    __pyx_v_args = __pyx_empty_tuple; __Pyx_INCREF(__pyx_empty_tuple);
-  }
+  __Pyx_RefNannySetupContext("WMA (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self,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) {
-        default:
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(4, 5293, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 5293, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 5293, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
+        default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_self)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "WMA", 0) < (0)) __PYX_ERR(4, 5293, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("WMA", 0, 1, 2, i); __PYX_ERR(4, 5293, __pyx_L3_error) }
       }
-      if (unlikely(kw_args > 0)) {
-        const Py_ssize_t used_pos_args = (pos_args < 1) ? pos_args : 1;
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, __pyx_v_kwargs, values, used_pos_args, "set_function_args") < 0)) __PYX_ERR(1, 252, __pyx_L3_error)
+    } else {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(4, 5293, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(4, 5293, __pyx_L3_error)
+        break;
+        default: goto __pyx_L5_argtuple_error;
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) < 1) {
-      goto __pyx_L5_argtuple_error;
+    }
+    __pyx_v_real = ((PyArrayObject *)values[0]);
+    if (values[1]) {
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(4, 5295, __pyx_L3_error)
     } else {
-      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
     }
-    __pyx_v_self = values[0];
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("set_function_args", 0, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 252, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("WMA", 0, 1, 2, __pyx_nargs); __PYX_ERR(4, 5293, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_DECREF(__pyx_v_args); __pyx_v_args = 0;
-  __Pyx_DECREF(__pyx_v_kwargs); __pyx_v_kwargs = 0;
-  __Pyx_AddTraceback("talib._ta_lib.Function.set_function_args", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.WMA", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_8Function_22set_function_args(__pyx_self, __pyx_v_self, __pyx_v_args, __pyx_v_kwargs);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(4, 5295, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_338WMA(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
 
   /* function exit code */
-  __Pyx_XDECREF(__pyx_v_args);
-  __Pyx_XDECREF(__pyx_v_kwargs);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
+  __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_22set_function_args(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_args, PyObject *__pyx_v_kwargs) {
-  int __pyx_v_update_info;
-  PyObject *__pyx_v_key = NULL;
-  PyObject *__pyx_v_value = NULL;
-  PyObject *__pyx_v_skip_first = NULL;
-  PyObject *__pyx_v_i = NULL;
-  PyObject *__pyx_v_param_name = NULL;
+static PyObject *__pyx_pf_5talib_7_ta_lib_338WMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
+  npy_intp __pyx_v_length;
+  int __pyx_v_begidx;
+  int __pyx_v_endidx;
+  int __pyx_v_lookback;
+  TA_RetCode __pyx_v_retCode;
+  int __pyx_v_outbegidx;
+  int __pyx_v_outnbelement;
+  PyArrayObject *__pyx_v_outreal = 0;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  Py_ssize_t __pyx_t_2;
-  Py_ssize_t __pyx_t_3;
-  int __pyx_t_4;
-  PyObject *__pyx_t_5 = NULL;
-  int __pyx_t_6;
-  int __pyx_t_7;
-  int __pyx_t_8;
-  PyObject *__pyx_t_9 = NULL;
-  PyObject *__pyx_t_10 = NULL;
-  PyObject *__pyx_t_11 = NULL;
-  PyObject *(*__pyx_t_12)(PyObject *);
-  PyObject *__pyx_t_13 = NULL;
-  __Pyx_RefNannySetupContext("set_function_args", 0);
+  npy_int __pyx_t_2;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("WMA", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_v_update_info = 0;
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5314, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
 
-  __pyx_t_2 = 0;
-  __pyx_t_5 = __Pyx_dict_iterator(__pyx_v_kwargs, 1, ((PyObject *)NULL), (&__pyx_t_3), (&__pyx_t_4)); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 258, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_5);
-  __Pyx_XDECREF(__pyx_t_1);
-  __pyx_t_1 = __pyx_t_5;
-  __pyx_t_5 = 0;
-  while (1) {
-    __pyx_t_6 = __Pyx_dict_iter_next(__pyx_t_1, __pyx_t_3, &__pyx_t_2, &__pyx_t_5, NULL, NULL, __pyx_t_4);
-    if (unlikely(__pyx_t_6 == 0)) break;
-    if (unlikely(__pyx_t_6 == -1)) __PYX_ERR(1, 258, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_5);
-    __Pyx_XDECREF_SET(__pyx_v_key, __pyx_t_5);
-    __pyx_t_5 = 0;
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
-    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__opt_inputs); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 259, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_5);
-    __pyx_t_7 = (__Pyx_PySequence_ContainsTF(__pyx_v_key, __pyx_t_5, Py_EQ)); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(1, 259, __pyx_L1_error)
-    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-    __pyx_t_8 = (__pyx_t_7 != 0);
-    if (__pyx_t_8) {
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_begidx1(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real))); if (unlikely(__pyx_t_2 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 5316, __pyx_L1_error)
+  __pyx_v_begidx = __pyx_t_2;
 
-      __pyx_t_5 = __Pyx_PyDict_GetItem(__pyx_v_kwargs, __pyx_v_key); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 260, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_5);
-      __Pyx_XDECREF_SET(__pyx_v_value, __pyx_t_5);
-      __pyx_t_5 = 0;
+  __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1);
 
-      __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__check_opt_input_value); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 261, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_9);
-      __pyx_t_10 = NULL;
-      __pyx_t_6 = 0;
-      if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_9))) {
-        __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_9);
-        if (likely(__pyx_t_10)) {
-          PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_9);
-          __Pyx_INCREF(__pyx_t_10);
-          __Pyx_INCREF(function);
-          __Pyx_DECREF_SET(__pyx_t_9, function);
-          __pyx_t_6 = 1;
-        }
-      }
-      #if CYTHON_FAST_PYCALL
-      if (PyFunction_Check(__pyx_t_9)) {
-        PyObject *__pyx_temp[3] = {__pyx_t_10, __pyx_v_key, __pyx_v_value};
-        __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_9, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 261, __pyx_L1_error)
-        __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
-        __Pyx_GOTREF(__pyx_t_5);
-      } else
-      #endif
-      #if CYTHON_FAST_PYCCALL
-      if (__Pyx_PyFastCFunction_Check(__pyx_t_9)) {
-        PyObject *__pyx_temp[3] = {__pyx_t_10, __pyx_v_key, __pyx_v_value};
-        __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_9, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 261, __pyx_L1_error)
-        __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
-        __Pyx_GOTREF(__pyx_t_5);
-      } else
-      #endif
-      {
-        __pyx_t_11 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_11)) __PYX_ERR(1, 261, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_11);
-        if (__pyx_t_10) {
-          __Pyx_GIVEREF(__pyx_t_10); PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_10); __pyx_t_10 = NULL;
-        }
-        __Pyx_INCREF(__pyx_v_key);
-        __Pyx_GIVEREF(__pyx_v_key);
-        PyTuple_SET_ITEM(__pyx_t_11, 0+__pyx_t_6, __pyx_v_key);
-        __Pyx_INCREF(__pyx_v_value);
-        __Pyx_GIVEREF(__pyx_v_value);
-        PyTuple_SET_ITEM(__pyx_t_11, 1+__pyx_t_6, __pyx_v_value);
-        __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_9, __pyx_t_11, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 261, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_5);
-        __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
-      }
-      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
-      __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_8 < 0)) __PYX_ERR(1, 261, __pyx_L1_error)
-      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-      if (__pyx_t_8) {
+  __pyx_v_lookback = (__pyx_v_begidx + TA_WMA_Lookback(__pyx_v_timeperiod));
 
-        __pyx_t_5 = __Pyx_PyDict_GetItem(__pyx_v_kwargs, __pyx_v_key); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 262, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_5);
-        __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__opt_inputs); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 262, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_9);
-        __pyx_t_11 = __Pyx_PyObject_GetItem(__pyx_t_9, __pyx_v_key); if (unlikely(!__pyx_t_11)) __PYX_ERR(1, 262, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_11);
-        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
-        if (unlikely(PyObject_SetItem(__pyx_t_11, __pyx_n_s_value, __pyx_t_5) < 0)) __PYX_ERR(1, 262, __pyx_L1_error)
-        __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
-        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_make_double_array(__pyx_v_length, __pyx_v_lookback)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5319, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1);
+  __pyx_t_1 = 0;
 
-        __pyx_v_update_info = 1;
+  __pyx_v_retCode = TA_WMA(0, __pyx_v_endidx, (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)) + __pyx_v_begidx), __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)) + __pyx_v_lookback));
 
-      }
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_WMA, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 5321, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
-      goto __pyx_L5;
-    }
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF((PyObject *)__pyx_v_outreal);
+  __pyx_r = ((PyObject *)__pyx_v_outreal);
+  goto __pyx_L0;
 
-    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__input_names); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 264, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_5);
-    __pyx_t_8 = (__Pyx_PySequence_ContainsTF(__pyx_v_key, __pyx_t_5, Py_EQ)); if (unlikely(__pyx_t_8 < 0)) __PYX_ERR(1, 264, __pyx_L1_error)
-    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-    __pyx_t_7 = (__pyx_t_8 != 0);
-    if (__pyx_t_7) {
 
-      __pyx_t_5 = __Pyx_PyDict_GetItem(__pyx_v_kwargs, __pyx_v_key); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 265, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_5);
-      __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__input_names); if (unlikely(!__pyx_t_11)) __PYX_ERR(1, 265, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_11);
-      __pyx_t_9 = __Pyx_PyObject_GetItem(__pyx_t_11, __pyx_v_key); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 265, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_9);
-      __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
-      if (unlikely(PyObject_SetItem(__pyx_t_9, __pyx_n_s_price_series, __pyx_t_5) < 0)) __PYX_ERR(1, 265, __pyx_L1_error)
-      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
-      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("talib._ta_lib.WMA", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_outreal);
+  __Pyx_XDECREF((PyObject *)__pyx_v_real);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
 
-      __pyx_t_5 = __Pyx_PyDict_GetItem(__pyx_v_kwargs, __pyx_v_key); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 266, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_5);
-      __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__info); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 266, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_9);
-      __pyx_t_11 = __Pyx_PyObject_Dict_GetItem(__pyx_t_9, __pyx_n_s_input_names); if (unlikely(!__pyx_t_11)) __PYX_ERR(1, 266, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_11);
-      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
-      if (unlikely(PyObject_SetItem(__pyx_t_11, __pyx_v_key, __pyx_t_5) < 0)) __PYX_ERR(1, 266, __pyx_L1_error)
-      __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
-      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
 
-    }
-    __pyx_L5:;
-  }
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-
-  __pyx_t_7 = (PyTuple_GET_SIZE(__pyx_v_args) != 0);
-  if (__pyx_t_7) {
-
-    __Pyx_INCREF(__pyx_int_0);
-    __pyx_v_skip_first = __pyx_int_0;
-
-    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_set_input_arrays); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 270, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_5);
-    __pyx_t_11 = __Pyx_GetItemInt_Tuple(__pyx_v_args, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_11)) __PYX_ERR(1, 270, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_11);
-    __pyx_t_9 = NULL;
-    if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) {
-      __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_5);
-      if (likely(__pyx_t_9)) {
-        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
-        __Pyx_INCREF(__pyx_t_9);
-        __Pyx_INCREF(function);
-        __Pyx_DECREF_SET(__pyx_t_5, function);
-      }
-    }
-    __pyx_t_1 = (__pyx_t_9) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_9, __pyx_t_11) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_11);
-    __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
-    __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
-    if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 270, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_1);
-    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-    __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(1, 270, __pyx_L1_error)
-    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-    if (__pyx_t_7) {
-
-      __Pyx_INCREF(__pyx_int_1);
-      __Pyx_DECREF_SET(__pyx_v_skip_first, __pyx_int_1);
-
-    }
-
-    __pyx_t_3 = PyTuple_GET_SIZE(__pyx_v_args); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(1, 272, __pyx_L1_error)
-    __pyx_t_1 = PyInt_FromSsize_t(__pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 272, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_1);
-    __pyx_t_5 = PyObject_RichCompare(__pyx_t_1, __pyx_v_skip_first, Py_GT); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 272, __pyx_L1_error)
-    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-    __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(1, 272, __pyx_L1_error)
-    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-    if (__pyx_t_7) {
-
-      __Pyx_INCREF(__pyx_int_0);
-      __pyx_t_5 = __pyx_int_0;
-      __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__opt_inputs); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 273, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_1);
-      if (likely(PyList_CheckExact(__pyx_t_1)) || PyTuple_CheckExact(__pyx_t_1)) {
-        __pyx_t_11 = __pyx_t_1; __Pyx_INCREF(__pyx_t_11); __pyx_t_3 = 0;
-        __pyx_t_12 = NULL;
-      } else {
-        __pyx_t_3 = -1; __pyx_t_11 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_11)) __PYX_ERR(1, 273, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_11);
-        __pyx_t_12 = Py_TYPE(__pyx_t_11)->tp_iternext; if (unlikely(!__pyx_t_12)) __PYX_ERR(1, 273, __pyx_L1_error)
+/* Python wrapper */
+static PyObject *__pyx_pw_5talib_7_ta_lib_341str2bytes(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_340str2bytes, "str2bytes(s)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_341str2bytes = {"str2bytes", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_341str2bytes, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_340str2bytes};
+static PyObject *__pyx_pw_5talib_7_ta_lib_341str2bytes(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyObject *__pyx_v_s = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("str2bytes (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_s,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(2, 74, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 74, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
       }
-      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-      for (;;) {
-        if (likely(!__pyx_t_12)) {
-          if (likely(PyList_CheckExact(__pyx_t_11))) {
-            if (__pyx_t_3 >= PyList_GET_SIZE(__pyx_t_11)) break;
-            #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-            __pyx_t_1 = PyList_GET_ITEM(__pyx_t_11, __pyx_t_3); __Pyx_INCREF(__pyx_t_1); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(1, 273, __pyx_L1_error)
-            #else
-            __pyx_t_1 = PySequence_ITEM(__pyx_t_11, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 273, __pyx_L1_error)
-            __Pyx_GOTREF(__pyx_t_1);
-            #endif
-          } else {
-            if (__pyx_t_3 >= PyTuple_GET_SIZE(__pyx_t_11)) break;
-            #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-            __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_11, __pyx_t_3); __Pyx_INCREF(__pyx_t_1); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(1, 273, __pyx_L1_error)
-            #else
-            __pyx_t_1 = PySequence_ITEM(__pyx_t_11, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 273, __pyx_L1_error)
-            __Pyx_GOTREF(__pyx_t_1);
-            #endif
-          }
-        } else {
-          __pyx_t_1 = __pyx_t_12(__pyx_t_11);
-          if (unlikely(!__pyx_t_1)) {
-            PyObject* exc_type = PyErr_Occurred();
-            if (exc_type) {
-              if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
-              else __PYX_ERR(1, 273, __pyx_L1_error)
-            }
-            break;
-          }
-          __Pyx_GOTREF(__pyx_t_1);
-        }
-        __Pyx_XDECREF_SET(__pyx_v_param_name, __pyx_t_1);
-        __pyx_t_1 = 0;
-        __Pyx_INCREF(__pyx_t_5);
-        __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_5);
-        __pyx_t_1 = __Pyx_PyInt_AddObjC(__pyx_t_5, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 273, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_1);
-        __Pyx_DECREF(__pyx_t_5);
-        __pyx_t_5 = __pyx_t_1;
-        __pyx_t_1 = 0;
-
-        __pyx_t_1 = PyNumber_InPlaceAdd(__pyx_v_i, __pyx_v_skip_first); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 274, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_1);
-        __Pyx_DECREF_SET(__pyx_v_i, __pyx_t_1);
-        __pyx_t_1 = 0;
-
-        __pyx_t_2 = PyTuple_GET_SIZE(__pyx_v_args); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(1, 275, __pyx_L1_error)
-        __pyx_t_1 = PyInt_FromSsize_t(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 275, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_1);
-        __pyx_t_9 = PyObject_RichCompare(__pyx_v_i, __pyx_t_1, Py_LT); __Pyx_XGOTREF(__pyx_t_9); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 275, __pyx_L1_error)
-        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-        __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(1, 275, __pyx_L1_error)
-        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
-        if (__pyx_t_7) {
-
-          __pyx_t_9 = __Pyx_PyObject_GetItem(__pyx_v_args, __pyx_v_i); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 276, __pyx_L1_error)
-          __Pyx_GOTREF(__pyx_t_9);
-          __Pyx_XDECREF_SET(__pyx_v_value, __pyx_t_9);
-          __pyx_t_9 = 0;
-
-          __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__check_opt_input_value); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 277, __pyx_L1_error)
-          __Pyx_GOTREF(__pyx_t_1);
-          __pyx_t_10 = NULL;
-          __pyx_t_4 = 0;
-          if (CYTHON_UNPACK_METHODS && likely(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_4 = 1;
-            }
-          }
-          #if CYTHON_FAST_PYCALL
-          if (PyFunction_Check(__pyx_t_1)) {
-            PyObject *__pyx_temp[3] = {__pyx_t_10, __pyx_v_param_name, __pyx_v_value};
-            __pyx_t_9 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 277, __pyx_L1_error)
-            __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
-            __Pyx_GOTREF(__pyx_t_9);
-          } else
-          #endif
-          #if CYTHON_FAST_PYCCALL
-          if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) {
-            PyObject *__pyx_temp[3] = {__pyx_t_10, __pyx_v_param_name, __pyx_v_value};
-            __pyx_t_9 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 277, __pyx_L1_error)
-            __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
-            __Pyx_GOTREF(__pyx_t_9);
-          } else
-          #endif
-          {
-            __pyx_t_13 = PyTuple_New(2+__pyx_t_4); if (unlikely(!__pyx_t_13)) __PYX_ERR(1, 277, __pyx_L1_error)
-            __Pyx_GOTREF(__pyx_t_13);
-            if (__pyx_t_10) {
-              __Pyx_GIVEREF(__pyx_t_10); PyTuple_SET_ITEM(__pyx_t_13, 0, __pyx_t_10); __pyx_t_10 = NULL;
-            }
-            __Pyx_INCREF(__pyx_v_param_name);
-            __Pyx_GIVEREF(__pyx_v_param_name);
-            PyTuple_SET_ITEM(__pyx_t_13, 0+__pyx_t_4, __pyx_v_param_name);
-            __Pyx_INCREF(__pyx_v_value);
-            __Pyx_GIVEREF(__pyx_v_value);
-            PyTuple_SET_ITEM(__pyx_t_13, 1+__pyx_t_4, __pyx_v_value);
-            __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_13, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 277, __pyx_L1_error)
-            __Pyx_GOTREF(__pyx_t_9);
-            __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
-          }
-          __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-          __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(1, 277, __pyx_L1_error)
-          __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
-          if (__pyx_t_7) {
-
-            __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__opt_inputs); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 278, __pyx_L1_error)
-            __Pyx_GOTREF(__pyx_t_9);
-            __pyx_t_1 = __Pyx_PyObject_GetItem(__pyx_t_9, __pyx_v_param_name); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 278, __pyx_L1_error)
-            __Pyx_GOTREF(__pyx_t_1);
-            __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
-            if (unlikely(PyObject_SetItem(__pyx_t_1, __pyx_n_s_value, __pyx_v_value) < 0)) __PYX_ERR(1, 278, __pyx_L1_error)
-            __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-
-            __pyx_v_update_info = 1;
-
-          }
-
-        }
-
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "str2bytes", 0) < (0)) __PYX_ERR(2, 74, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("str2bytes", 1, 1, 1, i); __PYX_ERR(2, 74, __pyx_L3_error) }
       }
-      __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
-      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 74, __pyx_L3_error)
     }
-
+    __pyx_v_s = values[0];
   }
-
-  __pyx_t_8 = (PyTuple_GET_SIZE(__pyx_v_args) != 0);
-  if (!__pyx_t_8) {
-  } else {
-    __pyx_t_7 = __pyx_t_8;
-    goto __pyx_L15_bool_binop_done;
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("str2bytes", 1, 1, 1, __pyx_nargs); __PYX_ERR(2, 74, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
   }
-  __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_v_kwargs); if (unlikely(__pyx_t_8 < 0)) __PYX_ERR(1, 281, __pyx_L1_error)
-  __pyx_t_7 = __pyx_t_8;
-  __pyx_L15_bool_binop_done:;
-  if (__pyx_t_7) {
-
-    __pyx_t_7 = (__pyx_v_update_info != 0);
-    if (__pyx_t_7) {
-
-      __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_parameters); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 283, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_5);
-      __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__info); if (unlikely(!__pyx_t_11)) __PYX_ERR(1, 283, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_11);
-      if (unlikely(PyObject_SetItem(__pyx_t_11, __pyx_n_s_parameters, __pyx_t_5) < 0)) __PYX_ERR(1, 283, __pyx_L1_error)
-      __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
-      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __Pyx_AddTraceback("talib._ta_lib.str2bytes", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_340str2bytes(__pyx_self, __pyx_v_s);
 
-    }
+  /* function exit code */
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
 
-    if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_Function__outputs_valid, Py_False) < 0) __PYX_ERR(1, 284, __pyx_L1_error)
+static PyObject *__pyx_pf_5talib_7_ta_lib_340str2bytes(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_s) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  size_t __pyx_t_4;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("str2bytes", 0);
 
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_2 = NULL;
+  __Pyx_INCREF((PyObject *)(&PyBytes_Type));
+  __pyx_t_3 = ((PyObject *)(&PyBytes_Type)); 
+  __pyx_t_4 = 1;
+  {
+    PyObject *__pyx_callargs[3] = {__pyx_t_2, __pyx_v_s, __pyx_mstate_global->__pyx_n_u_ascii};
+    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_4, (3-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 75, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
   }
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
 
 
   /* function exit code */
-  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
-  goto __pyx_L0;
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_XDECREF(__pyx_t_5);
-  __Pyx_XDECREF(__pyx_t_9);
-  __Pyx_XDECREF(__pyx_t_10);
-  __Pyx_XDECREF(__pyx_t_11);
-  __Pyx_XDECREF(__pyx_t_13);
-  __Pyx_AddTraceback("talib._ta_lib.Function.set_function_args", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("talib._ta_lib.str2bytes", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF(__pyx_v_key);
-  __Pyx_XDECREF(__pyx_v_value);
-  __Pyx_XDECREF(__pyx_v_skip_first);
-  __Pyx_XDECREF(__pyx_v_i);
-  __Pyx_XDECREF(__pyx_v_param_name);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -33882,220 +40682,230 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_22set_function_args(CYTHON_U
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_25lookback(PyObject *__pyx_self, PyObject *__pyx_v_self); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_8Function_24lookback[] = "\n        Returns the lookback window size for the function with the parameter\n        values that are currently set.\n        ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_8Function_25lookback = {"lookback", (PyCFunction)__pyx_pw_5talib_7_ta_lib_8Function_25lookback, METH_O, __pyx_doc_5talib_7_ta_lib_8Function_24lookback};
-static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_25lookback(PyObject *__pyx_self, PyObject *__pyx_v_self) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_343bytes2str(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_342bytes2str, "bytes2str(b)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_343bytes2str = {"bytes2str", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_343bytes2str, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_342bytes2str};
+static PyObject *__pyx_pw_5talib_7_ta_lib_343bytes2str(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyObject *__pyx_v_b = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("lookback (wrapper)", 0);
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_8Function_24lookback(__pyx_self, ((PyObject *)__pyx_v_self));
+  __Pyx_RefNannySetupContext("bytes2str (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_b,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(2, 77, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 77, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "bytes2str", 0) < (0)) __PYX_ERR(2, 77, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("bytes2str", 1, 1, 1, i); __PYX_ERR(2, 77, __pyx_L3_error) }
+      }
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 77, __pyx_L3_error)
+    }
+    __pyx_v_b = values[0];
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("bytes2str", 1, 1, 1, __pyx_nargs); __PYX_ERR(2, 77, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.bytes2str", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_342bytes2str(__pyx_self, __pyx_v_b);
 
   /* function exit code */
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_24lookback(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
-  TA_ParamHolder *__pyx_v_holder;
-  PyObject *__pyx_v_i = NULL;
-  PyObject *__pyx_v_opt_input = NULL;
-  PyObject *__pyx_v_value = NULL;
-  PyObject *__pyx_v_type_ = NULL;
-  int __pyx_v_lookback;
+static PyObject *__pyx_pf_5talib_7_ta_lib_342bytes2str(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_b) {
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  char *__pyx_t_2;
-  PyObject *__pyx_t_3 = NULL;
-  PyObject *__pyx_t_4 = NULL;
-  Py_ssize_t __pyx_t_5;
-  PyObject *(*__pyx_t_6)(PyObject *);
-  PyObject *__pyx_t_7 = NULL;
-  PyObject *__pyx_t_8 = NULL;
-  int __pyx_t_9;
-  int __pyx_t_10;
-  int __pyx_t_11;
-  int __pyx_t_12;
-  __Pyx_RefNannySetupContext("lookback", 0);
-
-  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__name); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 293, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = __Pyx_PyObject_AsWritableString(__pyx_t_1); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) __PYX_ERR(1, 293, __pyx_L1_error)
-  __pyx_v_holder = __pyx_f_5talib_7_ta_lib___ta_paramHolderAlloc(__pyx_t_2);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  PyObject *__pyx_t_2 = NULL;
+  size_t __pyx_t_3;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("bytes2str", 0);
 
-  __Pyx_INCREF(__pyx_int_0);
-  __pyx_t_1 = __pyx_int_0;
-  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__opt_inputs); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 294, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (likely(PyList_CheckExact(__pyx_t_3)) || PyTuple_CheckExact(__pyx_t_3)) {
-    __pyx_t_4 = __pyx_t_3; __Pyx_INCREF(__pyx_t_4); __pyx_t_5 = 0;
-    __pyx_t_6 = NULL;
-  } else {
-    __pyx_t_5 = -1; __pyx_t_4 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 294, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_4);
-    __pyx_t_6 = Py_TYPE(__pyx_t_4)->tp_iternext; if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 294, __pyx_L1_error)
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_2 = __pyx_v_b;
+  __Pyx_INCREF(__pyx_t_2);
+  __pyx_t_3 = 0;
+  {
+    PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_mstate_global->__pyx_n_u_ascii};
+    __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_decode, __pyx_callargs+__pyx_t_3, (2-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+    if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 78, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
   }
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  for (;;) {
-    if (likely(!__pyx_t_6)) {
-      if (likely(PyList_CheckExact(__pyx_t_4))) {
-        if (__pyx_t_5 >= PyList_GET_SIZE(__pyx_t_4)) break;
-        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-        __pyx_t_3 = PyList_GET_ITEM(__pyx_t_4, __pyx_t_5); __Pyx_INCREF(__pyx_t_3); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(1, 294, __pyx_L1_error)
-        #else
-        __pyx_t_3 = PySequence_ITEM(__pyx_t_4, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 294, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_3);
-        #endif
-      } else {
-        if (__pyx_t_5 >= PyTuple_GET_SIZE(__pyx_t_4)) break;
-        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-        __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_4, __pyx_t_5); __Pyx_INCREF(__pyx_t_3); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(1, 294, __pyx_L1_error)
-        #else
-        __pyx_t_3 = PySequence_ITEM(__pyx_t_4, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 294, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_3);
-        #endif
-      }
-    } else {
-      __pyx_t_3 = __pyx_t_6(__pyx_t_4);
-      if (unlikely(!__pyx_t_3)) {
-        PyObject* exc_type = PyErr_Occurred();
-        if (exc_type) {
-          if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
-          else __PYX_ERR(1, 294, __pyx_L1_error)
-        }
-        break;
-      }
-      __Pyx_GOTREF(__pyx_t_3);
-    }
-    __Pyx_XDECREF_SET(__pyx_v_opt_input, __pyx_t_3);
-    __pyx_t_3 = 0;
-    __Pyx_INCREF(__pyx_t_1);
-    __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_1);
-    __pyx_t_3 = __Pyx_PyInt_AddObjC(__pyx_t_1, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 294, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_3);
-    __Pyx_DECREF(__pyx_t_1);
-    __pyx_t_1 = __pyx_t_3;
-    __pyx_t_3 = 0;
-
-    __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__get_opt_input_value); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 295, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_7);
-    __pyx_t_8 = NULL;
-    if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_7))) {
-      __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7);
-      if (likely(__pyx_t_8)) {
-        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7);
-        __Pyx_INCREF(__pyx_t_8);
-        __Pyx_INCREF(function);
-        __Pyx_DECREF_SET(__pyx_t_7, function);
-      }
-    }
-    __pyx_t_3 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_8, __pyx_v_opt_input) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_v_opt_input);
-    __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
-    if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 295, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_3);
-    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
-    __Pyx_XDECREF_SET(__pyx_v_value, __pyx_t_3);
-    __pyx_t_3 = 0;
-
-    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__opt_inputs); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 296, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_3);
-    __pyx_t_7 = __Pyx_PyObject_GetItem(__pyx_t_3, __pyx_v_opt_input); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 296, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_7);
-    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-    __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_t_7, __pyx_n_s_type_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 296, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_3);
-    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
-    __Pyx_XDECREF_SET(__pyx_v_type_, __pyx_t_3);
-    __pyx_t_3 = 0;
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
 
-    __pyx_t_3 = __Pyx_PyInt_From_TA_OptInputParameterType(TA_OptInput_RealRange); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 297, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_3);
-    __pyx_t_7 = PyObject_RichCompare(__pyx_v_type_, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 297, __pyx_L1_error)
-    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-    __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_10 < 0)) __PYX_ERR(1, 297, __pyx_L1_error)
-    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
-    if (!__pyx_t_10) {
-    } else {
-      __pyx_t_9 = __pyx_t_10;
-      goto __pyx_L6_bool_binop_done;
-    }
-    __pyx_t_7 = __Pyx_PyInt_From_TA_OptInputParameterType(TA_OptInput_RealList); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 297, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_7);
-    __pyx_t_3 = PyObject_RichCompare(__pyx_v_type_, __pyx_t_7, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 297, __pyx_L1_error)
-    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
-    __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_10 < 0)) __PYX_ERR(1, 297, __pyx_L1_error)
-    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-    __pyx_t_9 = __pyx_t_10;
-    __pyx_L6_bool_binop_done:;
-    if (__pyx_t_9) {
 
-      __pyx_t_11 = __Pyx_PyInt_As_int(__pyx_v_i); if (unlikely((__pyx_t_11 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 298, __pyx_L1_error)
-      __pyx_t_12 = __Pyx_PyInt_As_int(__pyx_v_value); if (unlikely((__pyx_t_12 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 298, __pyx_L1_error)
-      (void)(__pyx_f_5talib_7_ta_lib___ta_setOptInputParamReal(__pyx_v_holder, __pyx_t_11, __pyx_t_12));
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("talib._ta_lib.bytes2str", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
 
-      goto __pyx_L5;
-    }
 
-    __pyx_t_3 = __Pyx_PyInt_From_TA_OptInputParameterType(TA_OptInput_IntegerRange); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 299, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_3);
-    __pyx_t_7 = PyObject_RichCompare(__pyx_v_type_, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 299, __pyx_L1_error)
-    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-    __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_10 < 0)) __PYX_ERR(1, 299, __pyx_L1_error)
-    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
-    if (!__pyx_t_10) {
+/* Python wrapper */
+static PyObject *__pyx_pw_5talib_7_ta_lib_345str2bytes(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_344str2bytes, "str2bytes(s)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_345str2bytes = {"str2bytes", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_345str2bytes, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_344str2bytes};
+static PyObject *__pyx_pw_5talib_7_ta_lib_345str2bytes(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyObject *__pyx_v_s = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("str2bytes (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_s,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(2, 82, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 82, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "str2bytes", 0) < (0)) __PYX_ERR(2, 82, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("str2bytes", 1, 1, 1, i); __PYX_ERR(2, 82, __pyx_L3_error) }
+      }
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
     } else {
-      __pyx_t_9 = __pyx_t_10;
-      goto __pyx_L8_bool_binop_done;
-    }
-    __pyx_t_7 = __Pyx_PyInt_From_TA_OptInputParameterType(TA_OptInput_IntegerList); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 299, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_7);
-    __pyx_t_3 = PyObject_RichCompare(__pyx_v_type_, __pyx_t_7, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 299, __pyx_L1_error)
-    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
-    __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_10 < 0)) __PYX_ERR(1, 299, __pyx_L1_error)
-    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-    __pyx_t_9 = __pyx_t_10;
-    __pyx_L8_bool_binop_done:;
-    if (__pyx_t_9) {
-
-      __pyx_t_12 = __Pyx_PyInt_As_int(__pyx_v_i); if (unlikely((__pyx_t_12 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 300, __pyx_L1_error)
-      __pyx_t_11 = __Pyx_PyInt_As_int(__pyx_v_value); if (unlikely((__pyx_t_11 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 300, __pyx_L1_error)
-      (void)(__pyx_f_5talib_7_ta_lib___ta_setOptInputParamInteger(__pyx_v_holder, __pyx_t_12, __pyx_t_11));
-
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 82, __pyx_L3_error)
     }
-    __pyx_L5:;
-
+    __pyx_v_s = values[0];
   }
-  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("str2bytes", 1, 1, 1, __pyx_nargs); __PYX_ERR(2, 82, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.str2bytes", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_344str2bytes(__pyx_self, __pyx_v_s);
 
-  __pyx_v_lookback = __pyx_f_5talib_7_ta_lib___ta_getLookback(__pyx_v_holder);
+  /* function exit code */
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
 
-  (void)(__pyx_f_5talib_7_ta_lib___ta_paramHolderFree(__pyx_v_holder));
+static PyObject *__pyx_pf_5talib_7_ta_lib_344str2bytes(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_s) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("str2bytes", 0);
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_lookback); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 304, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_r = __pyx_t_1;
-  __pyx_t_1 = 0;
+  __Pyx_INCREF(__pyx_v_s);
+  __pyx_r = __pyx_v_s;
   goto __pyx_L0;
 
 
   /* 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_7);
-  __Pyx_XDECREF(__pyx_t_8);
-  __Pyx_AddTraceback("talib._ta_lib.Function.lookback", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF(__pyx_v_i);
-  __Pyx_XDECREF(__pyx_v_opt_input);
-  __Pyx_XDECREF(__pyx_v_value);
-  __Pyx_XDECREF(__pyx_v_type_);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -34103,80 +40913,104 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_24lookback(CYTHON_UNUSED PyO
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_27output_names(PyObject *__pyx_self, PyObject *__pyx_v_self); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_8Function_26output_names[] = "\n        Returns a list of the output names returned by this function.\n        ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_8Function_27output_names = {"output_names", (PyCFunction)__pyx_pw_5talib_7_ta_lib_8Function_27output_names, METH_O, __pyx_doc_5talib_7_ta_lib_8Function_26output_names};
-static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_27output_names(PyObject *__pyx_self, PyObject *__pyx_v_self) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_347bytes2str(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_346bytes2str, "bytes2str(b)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_347bytes2str = {"bytes2str", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_347bytes2str, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_346bytes2str};
+static PyObject *__pyx_pw_5talib_7_ta_lib_347bytes2str(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyObject *__pyx_v_b = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("output_names (wrapper)", 0);
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_8Function_26output_names(__pyx_self, ((PyObject *)__pyx_v_self));
+  __Pyx_RefNannySetupContext("bytes2str (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_b,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(2, 85, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 85, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "bytes2str", 0) < (0)) __PYX_ERR(2, 85, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("bytes2str", 1, 1, 1, i); __PYX_ERR(2, 85, __pyx_L3_error) }
+      }
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 85, __pyx_L3_error)
+    }
+    __pyx_v_b = values[0];
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("bytes2str", 1, 1, 1, __pyx_nargs); __PYX_ERR(2, 85, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.bytes2str", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_346bytes2str(__pyx_self, __pyx_v_b);
 
   /* function exit code */
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_26output_names(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
-  PyObject *__pyx_v_ret = NULL;
+static PyObject *__pyx_pf_5talib_7_ta_lib_346bytes2str(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_b) {
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
-  PyObject *__pyx_t_2 = NULL;
-  PyObject *__pyx_t_3 = NULL;
-  int __pyx_t_4;
-  int __pyx_t_5;
-  __Pyx_RefNannySetupContext("output_names", 0);
-
-  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__outputs); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 311, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_keys); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 311, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __pyx_t_2 = NULL;
-  if (CYTHON_UNPACK_METHODS && likely(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_1 = (__pyx_t_2) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2) : __Pyx_PyObject_CallNoArg(__pyx_t_3);
-  __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
-  if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 311, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __pyx_v_ret = __pyx_t_1;
-  __pyx_t_1 = 0;
-
-  __pyx_t_4 = PyList_Check(__pyx_v_ret); 
-  __pyx_t_5 = ((!(__pyx_t_4 != 0)) != 0);
-  if (__pyx_t_5) {
-
-    __pyx_t_1 = PySequence_List(__pyx_v_ret); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 313, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_1);
-    __Pyx_DECREF_SET(__pyx_v_ret, __pyx_t_1);
-    __pyx_t_1 = 0;
-
-  }
+  __Pyx_RefNannySetupContext("bytes2str", 0);
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(__pyx_v_ret);
-  __pyx_r = __pyx_v_ret;
+  __Pyx_INCREF(__pyx_v_b);
+  __pyx_r = __pyx_v_b;
   goto __pyx_L0;
 
 
   /* function exit code */
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_XDECREF(__pyx_t_2);
-  __Pyx_XDECREF(__pyx_t_3);
-  __Pyx_AddTraceback("talib._ta_lib.Function.output_names", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF(__pyx_v_ret);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -34184,376 +41018,234 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_26output_names(CYTHON_UNUSED
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_29outputs(PyObject *__pyx_self, PyObject *__pyx_v_self); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_8Function_28outputs[] = "\n        Returns the TA function values for the currently set input_arrays and\n        parameters. Returned values are a ndarray if there is only one output\n        or a list of ndarrays for more than one output.\n        ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_8Function_29outputs = {"outputs", (PyCFunction)__pyx_pw_5talib_7_ta_lib_8Function_29outputs, METH_O, __pyx_doc_5talib_7_ta_lib_8Function_28outputs};
-static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_29outputs(PyObject *__pyx_self, PyObject *__pyx_v_self) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_1__init__(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_8Function___init__, "Function.__init__(self, function_name, func_object, *args, **kwargs)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_8Function_1__init__ = {"__init__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_8Function_1__init__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_8Function___init__};
+static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_1__init__(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyObject *__pyx_v_self = 0;
+  PyObject *__pyx_v_function_name = 0;
+  PyObject *__pyx_v_func_object = 0;
+  PyObject *__pyx_v_args = 0;
+  PyObject *__pyx_v_kwargs = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[3] = {0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("outputs (wrapper)", 0);
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_8Function_28outputs(__pyx_self, ((PyObject *)__pyx_v_self));
+  __Pyx_RefNannySetupContext("__init__ (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  __pyx_v_kwargs = PyDict_New(); if (unlikely(!__pyx_v_kwargs)) return NULL;
+  __Pyx_GOTREF(__pyx_v_kwargs);
+  __pyx_v_args = __Pyx_ArgsSlice_FASTCALL(__pyx_args, 3, __pyx_nargs);
+  if (unlikely(!__pyx_v_args)) {
+    __Pyx_DECREF(__pyx_v_kwargs); __pyx_v_kwargs = 0;
+    __Pyx_RefNannyFinishContext();
+    return NULL;
+  }
+  __Pyx_GOTREF(__pyx_v_args);
+  {
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,&__pyx_mstate_global->__pyx_n_u_function_name,&__pyx_mstate_global->__pyx_n_u_func_object,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(2, 117, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        default:
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(2, 117, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(2, 117, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 117, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+      }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      const Py_ssize_t used_pos_args = (kwd_pos_args < 3) ? kwd_pos_args : 3;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, __pyx_v_kwargs, values, used_pos_args, __pyx_kwds_len, "__init__", 1) < (0)) __PYX_ERR(2, 117, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 3; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__init__", 0, 3, 3, i); __PYX_ERR(2, 117, __pyx_L3_error) }
+      }
+    } else if (unlikely(__pyx_nargs < 3)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 117, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(2, 117, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(2, 117, __pyx_L3_error)
+    }
+    __pyx_v_self = values[0];
+    __pyx_v_function_name = values[1];
+    __pyx_v_func_object = values[2];
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("__init__", 0, 3, 3, __pyx_nargs); __PYX_ERR(2, 117, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_DECREF(__pyx_v_args); __pyx_v_args = 0;
+  __Pyx_DECREF(__pyx_v_kwargs); __pyx_v_kwargs = 0;
+  __Pyx_AddTraceback("talib._ta_lib.Function.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_8Function___init__(__pyx_self, __pyx_v_self, __pyx_v_function_name, __pyx_v_func_object, __pyx_v_args, __pyx_v_kwargs);
 
   /* function exit code */
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_DECREF(__pyx_v_args);
+  __Pyx_DECREF(__pyx_v_kwargs);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_28outputs(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
-  PyObject *__pyx_v_ret = NULL;
-  PyObject *__pyx_v_index = NULL;
+static PyObject *__pyx_pf_5talib_7_ta_lib_8Function___init__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_function_name, PyObject *__pyx_v_func_object, PyObject *__pyx_v_args, PyObject *__pyx_v_kwargs) {
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  int __pyx_t_2;
-  int __pyx_t_3;
+  PyObject *__pyx_t_2 = NULL;
+  size_t __pyx_t_3;
   PyObject *__pyx_t_4 = NULL;
   PyObject *__pyx_t_5 = NULL;
-  int __pyx_t_6;
-  Py_ssize_t __pyx_t_7;
-  PyObject *__pyx_t_8 = NULL;
-  __Pyx_RefNannySetupContext("outputs", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__init__", 0);
+
+  __pyx_t_2 = __pyx_v_function_name;
+  __Pyx_INCREF(__pyx_t_2);
+  __pyx_t_3 = 0;
+  {
+    PyObject *__pyx_callargs[2] = {__pyx_t_2, NULL};
+    __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_upper, __pyx_callargs+__pyx_t_3, (1-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+    if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 119, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+  }
+  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_Function__name, __pyx_t_1) < (0)) __PYX_ERR(2, 119, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
-  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__outputs_valid); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 323, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_Function__name); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 120, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(1, 323, __pyx_L1_error)
+  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_Function__namestr, __pyx_t_1) < (0)) __PYX_ERR(2, 120, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_3 = ((!__pyx_t_2) != 0);
-  if (__pyx_t_3) {
 
-    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__call_function); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 324, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_4);
-    __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);
-      }
-    }
-    __pyx_t_1 = (__pyx_t_5) ? __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5) : __Pyx_PyObject_CallNoArg(__pyx_t_4);
-    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
-    if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 324, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_1);
-    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-
-  }
-
-  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__outputs); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 325, __pyx_L1_error)
+  __pyx_t_2 = NULL;
+  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_str2bytes); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 121, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
-  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_values); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 325, __pyx_L1_error)
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_Function__name); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 121, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_5);
-  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __pyx_t_4 = NULL;
-  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) {
-    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
-    if (likely(__pyx_t_4)) {
-      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
-      __Pyx_INCREF(__pyx_t_4);
-      __Pyx_INCREF(function);
-      __Pyx_DECREF_SET(__pyx_t_5, function);
-    }
+  __pyx_t_3 = 1;
+  #if CYTHON_UNPACK_METHODS
+  if (unlikely(PyMethod_Check(__pyx_t_4))) {
+    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_4);
+    assert(__pyx_t_2);
+    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
+    __Pyx_INCREF(__pyx_t_2);
+    __Pyx_INCREF(__pyx__function);
+    __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
+    __pyx_t_3 = 0;
   }
-  __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_5);
-  __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
-  if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 325, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-  __pyx_v_ret = __pyx_t_1;
-  __pyx_t_1 = 0;
-
-  __pyx_t_3 = PyList_Check(__pyx_v_ret); 
-  __pyx_t_2 = ((!(__pyx_t_3 != 0)) != 0);
-  if (__pyx_t_2) {
-
-    __pyx_t_1 = PySequence_List(__pyx_v_ret); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 327, __pyx_L1_error)
+  #endif
+  {
+    PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_t_5};
+    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_3, (2-__pyx_t_3) | (__pyx_t_3*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 121, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_1);
-    __Pyx_DECREF_SET(__pyx_v_ret, __pyx_t_1);
-    __pyx_t_1 = 0;
-
   }
-
-  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_PANDAS_DATAFRAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 328, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_3 = (__pyx_t_1 != Py_None);
+  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_Function__name, __pyx_t_1) < (0)) __PYX_ERR(2, 121, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_6 = (__pyx_t_3 != 0);
-  if (__pyx_t_6) {
-  } else {
-    __pyx_t_2 = __pyx_t_6;
-    goto __pyx_L6_bool_binop_done;
-  }
 
-  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__input_arrays); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 329, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_PANDAS_DATAFRAME); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 329, __pyx_L1_error)
+  __pyx_t_4 = NULL;
+  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_threading); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 124, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_5);
-  __pyx_t_6 = PyObject_IsInstance(__pyx_t_1, __pyx_t_5); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(1, 329, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_local); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 124, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
   __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-  __pyx_t_3 = (__pyx_t_6 != 0);
-  __pyx_t_2 = __pyx_t_3;
-  __pyx_L6_bool_binop_done:;
-
-  if (__pyx_t_2) {
-
-    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__input_arrays); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 330, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_5);
-    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_index); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 330, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_1);
-    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-    __pyx_v_index = __pyx_t_1;
-    __pyx_t_1 = 0;
-
-    __pyx_t_7 = PyObject_Length(__pyx_v_ret); if (unlikely(__pyx_t_7 == ((Py_ssize_t)-1))) __PYX_ERR(1, 331, __pyx_L1_error)
-    __pyx_t_2 = ((__pyx_t_7 == 1) != 0);
-    if (__pyx_t_2) {
-
-      __Pyx_XDECREF(__pyx_r);
-      __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_PANDAS_SERIES); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 332, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_1);
-      __pyx_t_5 = __Pyx_GetItemInt(__pyx_v_ret, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 332, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_5);
-      __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 332, __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 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 332, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_5);
-      if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_index, __pyx_v_index) < 0) __PYX_ERR(1, 332, __pyx_L1_error)
-      __pyx_t_8 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 332, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_8);
-      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-      __pyx_r = __pyx_t_8;
-      __pyx_t_8 = 0;
-      goto __pyx_L0;
-
-    }
-
-    /*else*/ {
-      __Pyx_XDECREF(__pyx_r);
-      __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_PANDAS_DATAFRAME); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 334, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_8);
-      __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_numpy); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 334, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_4);
-      __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_column_stack); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 334, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_1);
-      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-      __pyx_t_4 = NULL;
-      if (CYTHON_UNPACK_METHODS && unlikely(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);
-        }
-      }
-      __pyx_t_5 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_4, __pyx_v_ret) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_v_ret);
-      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
-      if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 334, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_5);
-      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-      __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 334, __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 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 335, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_5);
-      if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_index, __pyx_v_index) < 0) __PYX_ERR(1, 335, __pyx_L1_error)
-
-      __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_output_names); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 336, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_4);
-      if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_columns, __pyx_t_4) < 0) __PYX_ERR(1, 335, __pyx_L1_error)
-      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-
-      __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_1, __pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 334, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_4);
-      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
-      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-      __pyx_r = __pyx_t_4;
-      __pyx_t_4 = 0;
-      goto __pyx_L0;
-    }
-
-  }
-
-  /*else*/ {
-    __Pyx_XDECREF(__pyx_r);
-    __pyx_t_7 = PyObject_Length(__pyx_v_ret); if (unlikely(__pyx_t_7 == ((Py_ssize_t)-1))) __PYX_ERR(1, 338, __pyx_L1_error)
-    if (((__pyx_t_7 == 1) != 0)) {
-      __pyx_t_5 = __Pyx_GetItemInt(__pyx_v_ret, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 338, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_5);
-      __pyx_t_4 = __pyx_t_5;
-      __pyx_t_5 = 0;
-    } else {
-      __Pyx_INCREF(__pyx_v_ret);
-      __pyx_t_4 = __pyx_v_ret;
-    }
-    __pyx_r = __pyx_t_4;
-    __pyx_t_4 = 0;
-    goto __pyx_L0;
+  __pyx_t_3 = 1;
+  #if CYTHON_UNPACK_METHODS
+  if (unlikely(PyMethod_Check(__pyx_t_2))) {
+    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2);
+    assert(__pyx_t_4);
+    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_2);
+    __Pyx_INCREF(__pyx_t_4);
+    __Pyx_INCREF(__pyx__function);
+    __Pyx_DECREF_SET(__pyx_t_2, __pyx__function);
+    __pyx_t_3 = 0;
   }
-
-
-  /* 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_8);
-  __Pyx_AddTraceback("talib._ta_lib.Function.outputs", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = NULL;
-  __pyx_L0:;
-  __Pyx_XDECREF(__pyx_v_ret);
-  __Pyx_XDECREF(__pyx_v_index);
-  __Pyx_XGIVEREF(__pyx_r);
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-
-/* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_31run(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_8Function_30run[] = "\n        run([input_arrays=None])\n\n        This is a shortcut to the outputs property that also allows setting\n        the input_arrays dict.\n        ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_8Function_31run = {"run", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_8Function_31run, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_8Function_30run};
-static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_31run(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyObject *__pyx_v_self = 0;
-  PyObject *__pyx_v_input_arrays = 0;
-  PyObject *__pyx_r = 0;
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("run (wrapper)", 0);
+  #endif
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self,&__pyx_n_s_input_arrays,0};
-    PyObject* values[2] = {0,0};
-    values[1] = ((PyObject *)((PyObject *)Py_None));
-    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);
-        CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-        CYTHON_FALLTHROUGH;
-        case  0: break;
-        default: goto __pyx_L5_argtuple_error;
-      }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_self)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_input_arrays);
-          if (value) { values[1] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "run") < 0)) __PYX_ERR(1, 340, __pyx_L3_error)
-      }
-    } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-        break;
-        default: goto __pyx_L5_argtuple_error;
-      }
-    }
-    __pyx_v_self = values[0];
-    __pyx_v_input_arrays = values[1];
-  }
-  goto __pyx_L4_argument_unpacking_done;
-  __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("run", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 340, __pyx_L3_error)
-  __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.Function.run", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __Pyx_RefNannyFinishContext();
-  return NULL;
-  __pyx_L4_argument_unpacking_done:;
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_8Function_30run(__pyx_self, __pyx_v_self, __pyx_v_input_arrays);
-
-  /* function exit code */
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_30run(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_input_arrays) {
-  PyObject *__pyx_r = NULL;
-  __Pyx_RefNannyDeclarations
-  int __pyx_t_1;
-  PyObject *__pyx_t_2 = NULL;
-  PyObject *__pyx_t_3 = NULL;
-  PyObject *__pyx_t_4 = NULL;
-  __Pyx_RefNannySetupContext("run", 0);
-
-  __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_input_arrays); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 347, __pyx_L1_error)
-  if (__pyx_t_1) {
-
-    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_set_input_arrays); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 348, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_3);
-    __pyx_t_4 = NULL;
-    if (CYTHON_UNPACK_METHODS && likely(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_2 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_v_input_arrays) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_input_arrays);
+    PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL};
+    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+__pyx_t_3, (1-__pyx_t_3) | (__pyx_t_3*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
     __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
-    if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 348, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_2);
-    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
     __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-
+    if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 124, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
   }
+  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_Function__localdata, __pyx_t_1) < (0)) __PYX_ERR(2, 124, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
-  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__call_function); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 349, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = NULL;
-  if (CYTHON_UNPACK_METHODS && likely(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_2 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_3);
-  __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
-  if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 349, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_set_function_args); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 127, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = PyDict_Copy(__pyx_v_kwargs); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 127, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_v_args, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 127, __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_DECREF(__pyx_t_4); __pyx_t_4 = 0;
 
-  __Pyx_XDECREF(__pyx_r);
-  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_outputs); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 350, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_r = __pyx_t_2;
-  __pyx_t_2 = 0;
-  goto __pyx_L0;
+  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_func_object, __pyx_v_func_object) < (0)) __PYX_ERR(2, 128, __pyx_L1_error)
 
 
   /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
   __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("talib._ta_lib.Function.run", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_AddTraceback("talib._ta_lib.Function.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XGIVEREF(__pyx_r);
@@ -34563,619 +41255,709 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_30run(CYTHON_UNUSED PyObject
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_33__call__(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_8Function_32__call__[] = "\n        func_instance([input_arrays,] [parameter_args,] [input_price_series_kwargs,] [parameter_kwargs])\n\n        This is a shortcut to the outputs property that also allows setting\n        the input_arrays dict and function parameters.\n        ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_8Function_33__call__ = {"__call__", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_8Function_33__call__, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_8Function_32__call__};
-static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_33__call__(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_3__local(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_8Function_2__local, "Function.__local(self)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_8Function_3__local = {"__local", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_8Function_3__local, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_8Function_2__local};
+static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_3__local(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyObject *__pyx_v_self = 0;
-  PyObject *__pyx_v_args = 0;
-  PyObject *__pyx_v_kwargs = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__call__ (wrapper)", 0);
-  __pyx_v_kwargs = PyDict_New(); if (unlikely(!__pyx_v_kwargs)) return NULL;
-  __Pyx_GOTREF(__pyx_v_kwargs);
-  if (PyTuple_GET_SIZE(__pyx_args) > 1) {
-    __pyx_v_args = PyTuple_GetSlice(__pyx_args, 1, PyTuple_GET_SIZE(__pyx_args));
-    if (unlikely(!__pyx_v_args)) {
-      __Pyx_DECREF(__pyx_v_kwargs); __pyx_v_kwargs = 0;
-      __Pyx_RefNannyFinishContext();
-      return NULL;
-    }
-    __Pyx_GOTREF(__pyx_v_args);
-  } else {
-    __pyx_v_args = __pyx_empty_tuple; __Pyx_INCREF(__pyx_empty_tuple);
-  }
+  __Pyx_RefNannySetupContext("__local (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self,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) {
-        default:
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(2, 130, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 130, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
+        default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_self)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-      }
-      if (unlikely(kw_args > 0)) {
-        const Py_ssize_t used_pos_args = (pos_args < 1) ? pos_args : 1;
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, __pyx_v_kwargs, values, used_pos_args, "__call__") < 0)) __PYX_ERR(1, 352, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__local", 0) < (0)) __PYX_ERR(2, 130, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__local", 1, 1, 1, i); __PYX_ERR(2, 130, __pyx_L3_error) }
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) < 1) {
+    } else if (unlikely(__pyx_nargs != 1)) {
       goto __pyx_L5_argtuple_error;
     } else {
-      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 130, __pyx_L3_error)
     }
     __pyx_v_self = values[0];
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("__call__", 0, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 352, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("__local", 1, 1, 1, __pyx_nargs); __PYX_ERR(2, 130, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_DECREF(__pyx_v_args); __pyx_v_args = 0;
-  __Pyx_DECREF(__pyx_v_kwargs); __pyx_v_kwargs = 0;
-  __Pyx_AddTraceback("talib._ta_lib.Function.__call__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.Function.__local", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_8Function_32__call__(__pyx_self, __pyx_v_self, __pyx_v_args, __pyx_v_kwargs);
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_8Function_2__local(__pyx_self, __pyx_v_self);
 
   /* function exit code */
-  __Pyx_XDECREF(__pyx_v_args);
-  __Pyx_XDECREF(__pyx_v_kwargs);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_32__call__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_args, PyObject *__pyx_v_kwargs) {
-  PyObject *__pyx_v_opt_input_values = NULL;
-  PyObject *__pyx_v_input_arrays = NULL;
-  PyObject *__pyx_v_input_price_series_names = NULL;
+static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_2__local(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
+  PyObject *__pyx_v_local = NULL;
   PyObject *__pyx_v_i = NULL;
-  PyObject *__pyx_v_arg = NULL;
-  PyObject *__pyx_v_msg = NULL;
+  PyObject *__pyx_v_info = NULL;
+  PyObject *__pyx_v_input_name = NULL;
   PyObject *__pyx_v_param_name = NULL;
-  PyObject *__pyx_v_value = NULL;
+  PyObject *__pyx_v_output_name = NULL;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  PyObject *__pyx_t_2 = NULL;
-  PyObject *__pyx_t_3 = NULL;
+  int __pyx_t_2;
+  int __pyx_t_3;
   PyObject *__pyx_t_4 = NULL;
-  Py_ssize_t __pyx_t_5;
-  PyObject *(*__pyx_t_6)(PyObject *);
-  int __pyx_t_7;
-  int __pyx_t_8;
-  int __pyx_t_9;
-  PyObject *__pyx_t_10 = NULL;
-  PyObject *__pyx_t_11 = NULL;
-  PyObject *__pyx_t_12 = NULL;
-  int __pyx_t_13;
-  PyObject *__pyx_t_14 = NULL;
-  Py_ssize_t __pyx_t_15;
-  PyObject *__pyx_t_16 = NULL;
-  PyObject *__pyx_t_17 = NULL;
-  PyObject *__pyx_t_18 = NULL;
-  PyObject *(*__pyx_t_19)(PyObject *);
-  __Pyx_RefNannySetupContext("__call__", 0);
-  __Pyx_INCREF(__pyx_v_args);
+  PyObject *__pyx_t_5 = NULL;
+  size_t __pyx_t_6;
+  PyObject *__pyx_t_7 = NULL;
+  PyObject *__pyx_t_8 = NULL;
+  PyObject *__pyx_t_9 = NULL;
+  Py_ssize_t __pyx_t_10;
+  PyObject *(*__pyx_t_11)(PyObject *);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__local", 0);
 
-  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 360, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_Function__localdata); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 132, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_local = __pyx_t_1;
+  __pyx_t_1 = 0;
 
-  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__opt_inputs); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 361, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_keys); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 361, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_4);
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __pyx_t_3 = NULL;
-  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) {
-    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4);
-    if (likely(__pyx_t_3)) {
-      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
-      __Pyx_INCREF(__pyx_t_3);
-      __Pyx_INCREF(function);
-      __Pyx_DECREF_SET(__pyx_t_4, function);
-    }
-  }
-  __pyx_t_2 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_4);
-  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
-  if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 361, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  if (likely(PyList_CheckExact(__pyx_t_2)) || PyTuple_CheckExact(__pyx_t_2)) {
-    __pyx_t_4 = __pyx_t_2; __Pyx_INCREF(__pyx_t_4); __pyx_t_5 = 0;
-    __pyx_t_6 = NULL;
-  } else {
-    __pyx_t_5 = -1; __pyx_t_4 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 361, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_4);
-    __pyx_t_6 = Py_TYPE(__pyx_t_4)->tp_iternext; if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 361, __pyx_L1_error)
-  }
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  for (;;) {
-    if (likely(!__pyx_t_6)) {
-      if (likely(PyList_CheckExact(__pyx_t_4))) {
-        if (__pyx_t_5 >= PyList_GET_SIZE(__pyx_t_4)) break;
-        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-        __pyx_t_2 = PyList_GET_ITEM(__pyx_t_4, __pyx_t_5); __Pyx_INCREF(__pyx_t_2); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(1, 361, __pyx_L1_error)
-        #else
-        __pyx_t_2 = PySequence_ITEM(__pyx_t_4, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 361, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_2);
-        #endif
-      } else {
-        if (__pyx_t_5 >= PyTuple_GET_SIZE(__pyx_t_4)) break;
-        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-        __pyx_t_2 = PyTuple_GET_ITEM(__pyx_t_4, __pyx_t_5); __Pyx_INCREF(__pyx_t_2); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(1, 361, __pyx_L1_error)
-        #else
-        __pyx_t_2 = PySequence_ITEM(__pyx_t_4, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 361, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_2);
-        #endif
-      }
-    } else {
-      __pyx_t_2 = __pyx_t_6(__pyx_t_4);
-      if (unlikely(!__pyx_t_2)) {
-        PyObject* exc_type = PyErr_Occurred();
-        if (exc_type) {
-          if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
-          else __PYX_ERR(1, 361, __pyx_L1_error)
-        }
-        break;
-      }
-      __Pyx_GOTREF(__pyx_t_2);
-    }
-    __Pyx_XDECREF_SET(__pyx_v_param_name, __pyx_t_2);
-    __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_HasAttr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_info); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(2, 133, __pyx_L1_error)
+  __pyx_t_3 = (!__pyx_t_2);
+  if (__pyx_t_3) {
 
-    __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__opt_inputs); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 360, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_2);
-    __pyx_t_3 = __Pyx_PyObject_GetItem(__pyx_t_2, __pyx_v_param_name); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 360, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_3);
-    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-    __pyx_t_2 = __Pyx_PyObject_Dict_GetItem(__pyx_t_3, __pyx_n_s_value); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 360, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_2);
-    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-    __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 360, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_3);
-    __Pyx_INCREF(__pyx_v_param_name);
-    __Pyx_GIVEREF(__pyx_v_param_name);
-    PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_param_name);
-    __Pyx_GIVEREF(__pyx_t_2);
-    PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_2);
-    __pyx_t_2 = 0;
-    if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_3))) __PYX_ERR(1, 360, __pyx_L1_error)
-    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    if (__Pyx_PyObject_SetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_info, Py_None) < (0)) __PYX_ERR(2, 134, __pyx_L1_error)
 
-  }
-  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __pyx_v_opt_input_values = ((PyObject*)__pyx_t_1);
-  __pyx_t_1 = 0;
+    __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 135, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    if (__Pyx_PyObject_SetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_input_arrays, __pyx_t_1) < (0)) __PYX_ERR(2, 135, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
-  __pyx_t_1 = PySequence_List(__pyx_v_args); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 364, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_args, __pyx_t_1);
-  __pyx_t_1 = 0;
+    __pyx_t_4 = NULL;
+    __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_OrderedDict); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 138, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __pyx_t_6 = 1;
+    #if CYTHON_UNPACK_METHODS
+    if (unlikely(PyMethod_Check(__pyx_t_5))) {
+      __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
+      assert(__pyx_t_4);
+      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
+      __Pyx_INCREF(__pyx_t_4);
+      __Pyx_INCREF(__pyx__function);
+      __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
+      __pyx_t_6 = 0;
+    }
+    #endif
+    {
+      PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL};
+      __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 138, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+    }
+    if (__Pyx_PyObject_SetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_input_names, __pyx_t_1) < (0)) __PYX_ERR(2, 138, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
-  __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 365, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_v_input_arrays = ((PyObject*)__pyx_t_1);
-  __pyx_t_1 = 0;
+    __pyx_t_5 = NULL;
+    __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_OrderedDict); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 139, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_6 = 1;
+    #if CYTHON_UNPACK_METHODS
+    if (unlikely(PyMethod_Check(__pyx_t_4))) {
+      __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4);
+      assert(__pyx_t_5);
+      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
+      __Pyx_INCREF(__pyx_t_5);
+      __Pyx_INCREF(__pyx__function);
+      __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
+      __pyx_t_6 = 0;
+    }
+    #endif
+    {
+      PyObject *__pyx_callargs[2] = {__pyx_t_5, NULL};
+      __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 139, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+    }
+    if (__Pyx_PyObject_SetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_opt_inputs, __pyx_t_1) < (0)) __PYX_ERR(2, 139, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
-  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__input_price_series_na); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 366, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_4);
-  __pyx_t_3 = NULL;
-  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) {
-    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4);
-    if (likely(__pyx_t_3)) {
-      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
-      __Pyx_INCREF(__pyx_t_3);
-      __Pyx_INCREF(function);
-      __Pyx_DECREF_SET(__pyx_t_4, function);
+    __pyx_t_4 = NULL;
+    __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_OrderedDict); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 140, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __pyx_t_6 = 1;
+    #if CYTHON_UNPACK_METHODS
+    if (unlikely(PyMethod_Check(__pyx_t_5))) {
+      __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
+      assert(__pyx_t_4);
+      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
+      __Pyx_INCREF(__pyx_t_4);
+      __Pyx_INCREF(__pyx__function);
+      __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
+      __pyx_t_6 = 0;
     }
-  }
-  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_4);
-  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
-  if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 366, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __pyx_v_input_price_series_names = __pyx_t_1;
-  __pyx_t_1 = 0;
+    #endif
+    {
+      PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL};
+      __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 140, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+    }
+    if (__Pyx_PyObject_SetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_outputs, __pyx_t_1) < (0)) __PYX_ERR(2, 140, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
-  __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_v_args); if (unlikely(__pyx_t_8 < 0)) __PYX_ERR(1, 367, __pyx_L1_error)
-  if (__pyx_t_8) {
-  } else {
-    __pyx_t_7 = __pyx_t_8;
-    goto __pyx_L6_bool_binop_done;
-  }
-  __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_args, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 367, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_INPUT_ARRAYS_TYPES); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 367, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_4);
-  __pyx_t_8 = PyObject_IsInstance(__pyx_t_1, __pyx_t_4); if (unlikely(__pyx_t_8 == ((int)-1))) __PYX_ERR(1, 367, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __pyx_t_9 = ((!(__pyx_t_8 != 0)) != 0);
-  __pyx_t_7 = __pyx_t_9;
-  __pyx_L6_bool_binop_done:;
-  if (__pyx_t_7) {
+    if (__Pyx_PyObject_SetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_outputs_valid, Py_False) < (0)) __PYX_ERR(2, 141, __pyx_L1_error)
 
-    __Pyx_INCREF(__pyx_int_0);
-    __pyx_t_4 = __pyx_int_0;
-    if (likely(PyList_CheckExact(__pyx_v_args)) || PyTuple_CheckExact(__pyx_v_args)) {
-      __pyx_t_1 = __pyx_v_args; __Pyx_INCREF(__pyx_t_1); __pyx_t_5 = 0;
-      __pyx_t_6 = NULL;
-    } else {
-      __pyx_t_5 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_v_args); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 368, __pyx_L1_error)
+    __pyx_t_5 = NULL;
+    __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_ta_getFuncInfo); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 144, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_Function__name); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 144, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    __pyx_t_6 = 1;
+    #if CYTHON_UNPACK_METHODS
+    if (unlikely(PyMethod_Check(__pyx_t_4))) {
+      __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4);
+      assert(__pyx_t_5);
+      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
+      __Pyx_INCREF(__pyx_t_5);
+      __Pyx_INCREF(__pyx__function);
+      __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
+      __pyx_t_6 = 0;
+    }
+    #endif
+    {
+      PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_7};
+      __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 144, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+    }
+    if (__Pyx_PyObject_SetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_info, __pyx_t_1) < (0)) __PYX_ERR(2, 144, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+    __pyx_t_4 = NULL;
+    __Pyx_INCREF(__pyx_builtin_xrange);
+    __pyx_t_7 = __pyx_builtin_xrange; 
+    __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_info); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 147, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_9);
+    __pyx_t_8 = __pyx_t_9;
+    __Pyx_INCREF(__pyx_t_8);
+    __pyx_t_6 = 0;
+    {
+      PyObject *__pyx_callargs[2] = {__pyx_t_8, __pyx_mstate_global->__pyx_n_u_num_inputs};
+      __pyx_t_5 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_pop, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+      __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+      if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 147, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_5);
+    }
+    __pyx_t_6 = 1;
+    {
+      PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_5};
+      __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_7, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+      if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 147, __pyx_L1_error)
       __Pyx_GOTREF(__pyx_t_1);
-      __pyx_t_6 = Py_TYPE(__pyx_t_1)->tp_iternext; if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 368, __pyx_L1_error)
     }
+    if (likely(PyList_CheckExact(__pyx_t_1)) || PyTuple_CheckExact(__pyx_t_1)) {
+      __pyx_t_7 = __pyx_t_1; __Pyx_INCREF(__pyx_t_7);
+      __pyx_t_10 = 0;
+      __pyx_t_11 = NULL;
+    } else {
+      __pyx_t_10 = -1; __pyx_t_7 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 147, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_7);
+      __pyx_t_11 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_7); if (unlikely(!__pyx_t_11)) __PYX_ERR(2, 147, __pyx_L1_error)
+    }
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
     for (;;) {
-      if (likely(!__pyx_t_6)) {
-        if (likely(PyList_CheckExact(__pyx_t_1))) {
-          if (__pyx_t_5 >= PyList_GET_SIZE(__pyx_t_1)) break;
-          #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-          __pyx_t_3 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_5); __Pyx_INCREF(__pyx_t_3); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(1, 368, __pyx_L1_error)
-          #else
-          __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 368, __pyx_L1_error)
-          __Pyx_GOTREF(__pyx_t_3);
-          #endif
+      if (likely(!__pyx_t_11)) {
+        if (likely(PyList_CheckExact(__pyx_t_7))) {
+          {
+            Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_7);
+            #if !CYTHON_ASSUME_SAFE_SIZE
+            if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 147, __pyx_L1_error)
+            #endif
+            if (__pyx_t_10 >= __pyx_temp) break;
+          }
+          __pyx_t_1 = __Pyx_PyList_GetItemRef(__pyx_t_7, __pyx_t_10);
+          ++__pyx_t_10;
         } else {
-          if (__pyx_t_5 >= PyTuple_GET_SIZE(__pyx_t_1)) break;
+          {
+            Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_7);
+            #if !CYTHON_ASSUME_SAFE_SIZE
+            if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 147, __pyx_L1_error)
+            #endif
+            if (__pyx_t_10 >= __pyx_temp) break;
+          }
           #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-          __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_5); __Pyx_INCREF(__pyx_t_3); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(1, 368, __pyx_L1_error)
+          __pyx_t_1 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_7, __pyx_t_10));
           #else
-          __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 368, __pyx_L1_error)
-          __Pyx_GOTREF(__pyx_t_3);
+          __pyx_t_1 = __Pyx_PySequence_ITEM(__pyx_t_7, __pyx_t_10);
           #endif
+          ++__pyx_t_10;
         }
+        if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 147, __pyx_L1_error)
       } else {
-        __pyx_t_3 = __pyx_t_6(__pyx_t_1);
-        if (unlikely(!__pyx_t_3)) {
+        __pyx_t_1 = __pyx_t_11(__pyx_t_7);
+        if (unlikely(!__pyx_t_1)) {
           PyObject* exc_type = PyErr_Occurred();
           if (exc_type) {
-            if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
-            else __PYX_ERR(1, 368, __pyx_L1_error)
+            if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(2, 147, __pyx_L1_error)
+            PyErr_Clear();
           }
           break;
         }
-        __Pyx_GOTREF(__pyx_t_3);
       }
-      __Pyx_XDECREF_SET(__pyx_v_arg, __pyx_t_3);
-      __pyx_t_3 = 0;
-      __Pyx_INCREF(__pyx_t_4);
-      __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_4);
-      __pyx_t_3 = __Pyx_PyInt_AddObjC(__pyx_t_4, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 368, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_3);
-      __Pyx_DECREF(__pyx_t_4);
-      __pyx_t_4 = __pyx_t_3;
-      __pyx_t_3 = 0;
-
-      __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_ARRAY_TYPES); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 369, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_3);
-      __pyx_t_7 = PyObject_IsInstance(__pyx_v_arg, __pyx_t_3); if (unlikely(__pyx_t_7 == ((int)-1))) __PYX_ERR(1, 369, __pyx_L1_error)
-      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-      __pyx_t_9 = ((!(__pyx_t_7 != 0)) != 0);
-      if (__pyx_t_9) {
-
-        goto __pyx_L9_break;
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_1);
+      __pyx_t_1 = 0;
 
+      __pyx_t_5 = NULL;
+      __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_ta_getInputParameterInfo); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 148, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_Function__name); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 148, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_9);
+      __pyx_t_6 = 1;
+      #if CYTHON_UNPACK_METHODS
+      if (unlikely(PyMethod_Check(__pyx_t_4))) {
+        __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4);
+        assert(__pyx_t_5);
+        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
+        __Pyx_INCREF(__pyx_t_5);
+        __Pyx_INCREF(__pyx__function);
+        __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
+        __pyx_t_6 = 0;
       }
-
+      #endif
       {
-        __Pyx_PyThreadState_declare
-        __Pyx_PyThreadState_assign
-        __Pyx_ExceptionSave(&__pyx_t_10, &__pyx_t_11, &__pyx_t_12);
-        __Pyx_XGOTREF(__pyx_t_10);
-        __Pyx_XGOTREF(__pyx_t_11);
-        __Pyx_XGOTREF(__pyx_t_12);
-        /*try:*/ {
-
-          __pyx_t_3 = __Pyx_PyObject_GetItem(__pyx_v_input_price_series_names, __pyx_v_i); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 373, __pyx_L11_error)
-          __Pyx_GOTREF(__pyx_t_3);
-          if (unlikely(PyDict_SetItem(__pyx_v_input_arrays, __pyx_t_3, __pyx_v_arg) < 0)) __PYX_ERR(1, 373, __pyx_L11_error)
-          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-
-        }
-        __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
-        __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
-        __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
-        goto __pyx_L18_try_end;
-        __pyx_L11_error:;
-        __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
-        __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
-
-        __pyx_t_13 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_IndexError);
-        if (__pyx_t_13) {
-          __Pyx_AddTraceback("talib._ta_lib.Function.__call__", __pyx_clineno, __pyx_lineno, __pyx_filename);
-          if (__Pyx_GetException(&__pyx_t_3, &__pyx_t_2, &__pyx_t_14) < 0) __PYX_ERR(1, 374, __pyx_L13_except_error)
-          __Pyx_GOTREF(__pyx_t_3);
-          __Pyx_GOTREF(__pyx_t_2);
-          __Pyx_GOTREF(__pyx_t_14);
-
-          __pyx_t_15 = PyObject_Length(__pyx_v_input_price_series_names); if (unlikely(__pyx_t_15 == ((Py_ssize_t)-1))) __PYX_ERR(1, 376, __pyx_L13_except_error)
-          __pyx_t_16 = PyInt_FromSsize_t(__pyx_t_15); if (unlikely(!__pyx_t_16)) __PYX_ERR(1, 376, __pyx_L13_except_error)
-          __Pyx_GOTREF(__pyx_t_16);
+        PyObject *__pyx_callargs[3] = {__pyx_t_5, __pyx_t_9, __pyx_v_i};
+        __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+        __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+        if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 148, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_1);
+      }
+      __Pyx_XDECREF_SET(__pyx_v_info, __pyx_t_1);
+      __pyx_t_1 = 0;
 
-          __pyx_t_17 = __Pyx_PyString_Join(__pyx_kp_s__6, __pyx_v_input_price_series_names); if (unlikely(!__pyx_t_17)) __PYX_ERR(1, 377, __pyx_L13_except_error)
-          __Pyx_GOTREF(__pyx_t_17);
+      __pyx_t_1 = __Pyx_PyObject_Dict_GetItem(__pyx_v_info, __pyx_mstate_global->__pyx_n_u_name); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 149, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_XDECREF_SET(__pyx_v_input_name, __pyx_t_1);
+      __pyx_t_1 = 0;
 
-          __pyx_t_18 = PyTuple_New(2); if (unlikely(!__pyx_t_18)) __PYX_ERR(1, 376, __pyx_L13_except_error)
-          __Pyx_GOTREF(__pyx_t_18);
-          __Pyx_GIVEREF(__pyx_t_16);
-          PyTuple_SET_ITEM(__pyx_t_18, 0, __pyx_t_16);
-          __Pyx_GIVEREF(__pyx_t_17);
-          PyTuple_SET_ITEM(__pyx_t_18, 1, __pyx_t_17);
-          __pyx_t_16 = 0;
-          __pyx_t_17 = 0;
-
-          __pyx_t_17 = __Pyx_PyString_Format(__pyx_kp_s_Too_many_price_arguments_expecte, __pyx_t_18); if (unlikely(!__pyx_t_17)) __PYX_ERR(1, 375, __pyx_L13_except_error)
-          __Pyx_GOTREF(__pyx_t_17);
-          __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
-          __pyx_v_msg = ((PyObject*)__pyx_t_17);
-          __pyx_t_17 = 0;
+      __pyx_t_1 = __Pyx_PyObject_Dict_GetItem(__pyx_v_info, __pyx_mstate_global->__pyx_n_u_price_series); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 150, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __pyx_t_3 = (__pyx_t_1 == Py_None);
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+      if (__pyx_t_3) {
 
-          __pyx_t_17 = __Pyx_PyObject_CallOneArg(__pyx_builtin_TypeError, __pyx_v_msg); if (unlikely(!__pyx_t_17)) __PYX_ERR(1, 378, __pyx_L13_except_error)
-          __Pyx_GOTREF(__pyx_t_17);
-          __Pyx_Raise(__pyx_t_17, 0, 0, 0);
-          __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
-          __PYX_ERR(1, 378, __pyx_L13_except_error)
-        }
-        goto __pyx_L13_except_error;
-        __pyx_L13_except_error:;
+        __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_INPUT_PRICE_SERIES_DEFAULTS); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 151, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_1);
+        __pyx_t_4 = __Pyx_PyObject_GetItem(__pyx_t_1, __pyx_v_input_name); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 151, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_4);
+        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+        if (unlikely((PyObject_SetItem(__pyx_v_info, __pyx_mstate_global->__pyx_n_u_price_series, __pyx_t_4) < 0))) __PYX_ERR(2, 151, __pyx_L1_error)
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
 
-        __Pyx_XGIVEREF(__pyx_t_10);
-        __Pyx_XGIVEREF(__pyx_t_11);
-        __Pyx_XGIVEREF(__pyx_t_12);
-        __Pyx_ExceptionReset(__pyx_t_10, __pyx_t_11, __pyx_t_12);
-        goto __pyx_L1_error;
-        __pyx_L18_try_end:;
       }
 
+      __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_input_names); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 152, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      if (unlikely((PyObject_SetItem(__pyx_t_4, __pyx_v_input_name, __pyx_v_info) < 0))) __PYX_ERR(2, 152, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
     }
-    __pyx_L9_break:;
-    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
 
-  }
+    __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_input_names); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 153, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_info); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 153, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    if (unlikely((PyObject_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_input_names, __pyx_t_7) < 0))) __PYX_ERR(2, 153, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
 
-  __pyx_t_5 = PyDict_Size(__pyx_v_input_arrays); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(1, 380, __pyx_L1_error)
-  __pyx_t_15 = PyObject_Length(__pyx_v_input_price_series_names); if (unlikely(__pyx_t_15 == ((Py_ssize_t)-1))) __PYX_ERR(1, 380, __pyx_L1_error)
-  __pyx_t_9 = ((__pyx_t_5 == __pyx_t_15) != 0);
-  if (__pyx_t_9) {
-
-    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_set_input_arrays); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 381, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_1);
-    __pyx_t_14 = NULL;
-    if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_1))) {
-      __pyx_t_14 = PyMethod_GET_SELF(__pyx_t_1);
-      if (likely(__pyx_t_14)) {
-        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1);
-        __Pyx_INCREF(__pyx_t_14);
-        __Pyx_INCREF(function);
-        __Pyx_DECREF_SET(__pyx_t_1, function);
-      }
+    __pyx_t_4 = NULL;
+    __Pyx_INCREF(__pyx_builtin_xrange);
+    __pyx_t_1 = __pyx_builtin_xrange; 
+    __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_info); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 156, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_8);
+    __pyx_t_5 = __pyx_t_8;
+    __Pyx_INCREF(__pyx_t_5);
+    __pyx_t_6 = 0;
+    {
+      PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_mstate_global->__pyx_n_u_num_opt_inputs};
+      __pyx_t_9 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_pop, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+      if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 156, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_9);
     }
-    __pyx_t_4 = (__pyx_t_14) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_14, __pyx_v_input_arrays) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_v_input_arrays);
-    __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0;
-    if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 381, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_4);
-    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-
-    __pyx_t_15 = PyDict_Size(__pyx_v_input_arrays); if (unlikely(__pyx_t_15 == ((Py_ssize_t)-1))) __PYX_ERR(1, 382, __pyx_L1_error)
-    __pyx_t_4 = __Pyx_PyList_GetSlice(__pyx_v_args, __pyx_t_15, PY_SSIZE_T_MAX); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 382, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_4);
-    __Pyx_DECREF_SET(__pyx_v_args, __pyx_t_4);
-    __pyx_t_4 = 0;
+    __pyx_t_6 = 1;
+    {
+      PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_9};
+      __pyx_t_7 = __Pyx_PyObject_FastCall(__pyx_t_1, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+      if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 156, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_7);
+    }
+    if (likely(PyList_CheckExact(__pyx_t_7)) || PyTuple_CheckExact(__pyx_t_7)) {
+      __pyx_t_1 = __pyx_t_7; __Pyx_INCREF(__pyx_t_1);
+      __pyx_t_10 = 0;
+      __pyx_t_11 = NULL;
+    } else {
+      __pyx_t_10 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 156, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __pyx_t_11 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_1); if (unlikely(!__pyx_t_11)) __PYX_ERR(2, 156, __pyx_L1_error)
+    }
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+    for (;;) {
+      if (likely(!__pyx_t_11)) {
+        if (likely(PyList_CheckExact(__pyx_t_1))) {
+          {
+            Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_1);
+            #if !CYTHON_ASSUME_SAFE_SIZE
+            if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 156, __pyx_L1_error)
+            #endif
+            if (__pyx_t_10 >= __pyx_temp) break;
+          }
+          __pyx_t_7 = __Pyx_PyList_GetItemRef(__pyx_t_1, __pyx_t_10);
+          ++__pyx_t_10;
+        } else {
+          {
+            Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_1);
+            #if !CYTHON_ASSUME_SAFE_SIZE
+            if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 156, __pyx_L1_error)
+            #endif
+            if (__pyx_t_10 >= __pyx_temp) break;
+          }
+          #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+          __pyx_t_7 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_10));
+          #else
+          __pyx_t_7 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_10);
+          #endif
+          ++__pyx_t_10;
+        }
+        if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 156, __pyx_L1_error)
+      } else {
+        __pyx_t_7 = __pyx_t_11(__pyx_t_1);
+        if (unlikely(!__pyx_t_7)) {
+          PyObject* exc_type = PyErr_Occurred();
+          if (exc_type) {
+            if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(2, 156, __pyx_L1_error)
+            PyErr_Clear();
+          }
+          break;
+        }
+      }
+      __Pyx_GOTREF(__pyx_t_7);
+      __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_7);
+      __pyx_t_7 = 0;
 
-    goto __pyx_L21;
-  }
+      __pyx_t_9 = NULL;
+      __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_ta_getOptInputParameterInfo); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 157, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_Function__name); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 157, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_8);
+      __pyx_t_6 = 1;
+      #if CYTHON_UNPACK_METHODS
+      if (unlikely(PyMethod_Check(__pyx_t_4))) {
+        __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_4);
+        assert(__pyx_t_9);
+        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
+        __Pyx_INCREF(__pyx_t_9);
+        __Pyx_INCREF(__pyx__function);
+        __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
+        __pyx_t_6 = 0;
+      }
+      #endif
+      {
+        PyObject *__pyx_callargs[3] = {__pyx_t_9, __pyx_t_8, __pyx_v_i};
+        __pyx_t_7 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+        __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+        if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 157, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_7);
+      }
+      __Pyx_XDECREF_SET(__pyx_v_info, __pyx_t_7);
+      __pyx_t_7 = 0;
 
-  __pyx_t_15 = PyDict_Size(__pyx_v_input_arrays); if (unlikely(__pyx_t_15 == ((Py_ssize_t)-1))) __PYX_ERR(1, 383, __pyx_L1_error)
-  __pyx_t_7 = (__pyx_t_15 != 0);
-  if (!__pyx_t_7) {
-  } else {
-    __pyx_t_9 = __pyx_t_7;
-    goto __pyx_L22_bool_binop_done;
-  }
-  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__input_arrays); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 383, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_4);
-  __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(1, 383, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __pyx_t_8 = ((!__pyx_t_7) != 0);
-  if (__pyx_t_8) {
-  } else {
-    __pyx_t_9 = __pyx_t_8;
-    goto __pyx_L22_bool_binop_done;
-  }
+      __pyx_t_7 = __Pyx_PyObject_Dict_GetItem(__pyx_v_info, __pyx_mstate_global->__pyx_n_u_name); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 158, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_7);
+      __Pyx_XDECREF_SET(__pyx_v_param_name, __pyx_t_7);
+      __pyx_t_7 = 0;
 
-  __pyx_t_15 = PyObject_Length(__pyx_v_args); if (unlikely(__pyx_t_15 == ((Py_ssize_t)-1))) __PYX_ERR(1, 384, __pyx_L1_error)
-  __pyx_t_8 = ((!(__pyx_t_15 != 0)) != 0);
-  if (!__pyx_t_8) {
-  } else {
-    __pyx_t_9 = __pyx_t_8;
-    goto __pyx_L22_bool_binop_done;
-  }
-  __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_args, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 384, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_4);
-  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_INPUT_ARRAYS_TYPES); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 384, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_8 = PyObject_IsInstance(__pyx_t_4, __pyx_t_1); if (unlikely(__pyx_t_8 == ((int)-1))) __PYX_ERR(1, 384, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_7 = ((!(__pyx_t_8 != 0)) != 0);
-  __pyx_t_9 = __pyx_t_7;
-  __pyx_L22_bool_binop_done:;
+      __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_opt_inputs); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 159, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_7);
+      if (unlikely((PyObject_SetItem(__pyx_t_7, __pyx_v_param_name, __pyx_v_info) < 0))) __PYX_ERR(2, 159, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
 
-  if (unlikely(__pyx_t_9)) {
+    }
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
-    __pyx_t_15 = PyObject_Length(__pyx_v_input_price_series_names); if (unlikely(__pyx_t_15 == ((Py_ssize_t)-1))) __PYX_ERR(1, 386, __pyx_L1_error)
-    __pyx_t_1 = PyInt_FromSsize_t(__pyx_t_15); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 386, __pyx_L1_error)
+    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_parameters); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 160, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_1);
+    __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_info); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 160, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    if (unlikely((PyObject_SetItem(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_parameters, __pyx_t_1) < 0))) __PYX_ERR(2, 160, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
-    __pyx_t_4 = __Pyx_PyString_Join(__pyx_kp_s__6, __pyx_v_input_price_series_names); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 387, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_4);
-
-    __pyx_t_14 = PyTuple_New(2); if (unlikely(!__pyx_t_14)) __PYX_ERR(1, 386, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_14);
-    __Pyx_GIVEREF(__pyx_t_1);
-    PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_1);
-    __Pyx_GIVEREF(__pyx_t_4);
-    PyTuple_SET_ITEM(__pyx_t_14, 1, __pyx_t_4);
-    __pyx_t_1 = 0;
-    __pyx_t_4 = 0;
-
-    __pyx_t_4 = __Pyx_PyString_Format(__pyx_kp_s_Not_enough_price_arguments_expec, __pyx_t_14); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 385, __pyx_L1_error)
+    __pyx_t_7 = NULL;
+    __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_OrderedDict); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 163, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_4);
-    __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
-    __pyx_v_msg = ((PyObject*)__pyx_t_4);
-    __pyx_t_4 = 0;
-
-    __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_builtin_TypeError, __pyx_v_msg); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 388, __pyx_L1_error)
+    __pyx_t_6 = 1;
+    #if CYTHON_UNPACK_METHODS
+    if (unlikely(PyMethod_Check(__pyx_t_4))) {
+      __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_4);
+      assert(__pyx_t_7);
+      PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
+      __Pyx_INCREF(__pyx_t_7);
+      __Pyx_INCREF(__pyx__function);
+      __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
+      __pyx_t_6 = 0;
+    }
+    #endif
+    {
+      PyObject *__pyx_callargs[2] = {__pyx_t_7, NULL};
+      __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 163, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+    }
+    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_info); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 163, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_4);
-    __Pyx_Raise(__pyx_t_4, 0, 0, 0);
+    if (unlikely((PyObject_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_output_flags, __pyx_t_1) < 0))) __PYX_ERR(2, 163, __pyx_L1_error)
     __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-    __PYX_ERR(1, 388, __pyx_L1_error)
-
-  }
-  __pyx_L21:;
-
-  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_set_function_args); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 390, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_4);
-  __pyx_t_14 = __Pyx_PySequence_Tuple(__pyx_v_args); if (unlikely(!__pyx_t_14)) __PYX_ERR(1, 390, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_14);
-  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_14, __pyx_v_kwargs); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 390, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
-  __pyx_t_14 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__call_function); if (unlikely(!__pyx_t_14)) __PYX_ERR(1, 391, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_14);
-  __pyx_t_4 = NULL;
-  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_14))) {
-    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_14);
-    if (likely(__pyx_t_4)) {
-      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_14);
-      __Pyx_INCREF(__pyx_t_4);
-      __Pyx_INCREF(function);
-      __Pyx_DECREF_SET(__pyx_t_14, function);
+    __pyx_t_4 = NULL;
+    __Pyx_INCREF(__pyx_builtin_xrange);
+    __pyx_t_7 = __pyx_builtin_xrange; 
+    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_info); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 164, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __pyx_t_9 = __pyx_t_5;
+    __Pyx_INCREF(__pyx_t_9);
+    __pyx_t_6 = 0;
+    {
+      PyObject *__pyx_callargs[2] = {__pyx_t_9, __pyx_mstate_global->__pyx_n_u_num_outputs};
+      __pyx_t_8 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_pop, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+      __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 164, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_8);
     }
-  }
-  __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_14, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_14);
-  __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
-  if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 391, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-
-  __pyx_t_1 = __pyx_v_opt_input_values; __Pyx_INCREF(__pyx_t_1); __pyx_t_15 = 0;
-  for (;;) {
-    if (__pyx_t_15 >= PyList_GET_SIZE(__pyx_t_1)) break;
-    #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-    __pyx_t_14 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_15); __Pyx_INCREF(__pyx_t_14); __pyx_t_15++; if (unlikely(0 < 0)) __PYX_ERR(1, 394, __pyx_L1_error)
-    #else
-    __pyx_t_14 = PySequence_ITEM(__pyx_t_1, __pyx_t_15); __pyx_t_15++; if (unlikely(!__pyx_t_14)) __PYX_ERR(1, 394, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_14);
-    #endif
-    if ((likely(PyTuple_CheckExact(__pyx_t_14))) || (PyList_CheckExact(__pyx_t_14))) {
-      PyObject* sequence = __pyx_t_14;
-      Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
-      if (unlikely(size != 2)) {
-        if (size > 2) __Pyx_RaiseTooManyValuesError(2);
-        else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
-        __PYX_ERR(1, 394, __pyx_L1_error)
-      }
-      #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-      if (likely(PyTuple_CheckExact(sequence))) {
-        __pyx_t_4 = PyTuple_GET_ITEM(sequence, 0); 
-        __pyx_t_2 = PyTuple_GET_ITEM(sequence, 1); 
+    __pyx_t_6 = 1;
+    {
+      PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_8};
+      __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_7, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+      if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 164, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+    }
+    if (likely(PyList_CheckExact(__pyx_t_1)) || PyTuple_CheckExact(__pyx_t_1)) {
+      __pyx_t_7 = __pyx_t_1; __Pyx_INCREF(__pyx_t_7);
+      __pyx_t_10 = 0;
+      __pyx_t_11 = NULL;
+    } else {
+      __pyx_t_10 = -1; __pyx_t_7 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 164, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_7);
+      __pyx_t_11 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_7); if (unlikely(!__pyx_t_11)) __PYX_ERR(2, 164, __pyx_L1_error)
+    }
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    for (;;) {
+      if (likely(!__pyx_t_11)) {
+        if (likely(PyList_CheckExact(__pyx_t_7))) {
+          {
+            Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_7);
+            #if !CYTHON_ASSUME_SAFE_SIZE
+            if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 164, __pyx_L1_error)
+            #endif
+            if (__pyx_t_10 >= __pyx_temp) break;
+          }
+          __pyx_t_1 = __Pyx_PyList_GetItemRef(__pyx_t_7, __pyx_t_10);
+          ++__pyx_t_10;
+        } else {
+          {
+            Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_7);
+            #if !CYTHON_ASSUME_SAFE_SIZE
+            if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 164, __pyx_L1_error)
+            #endif
+            if (__pyx_t_10 >= __pyx_temp) break;
+          }
+          #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+          __pyx_t_1 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_7, __pyx_t_10));
+          #else
+          __pyx_t_1 = __Pyx_PySequence_ITEM(__pyx_t_7, __pyx_t_10);
+          #endif
+          ++__pyx_t_10;
+        }
+        if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 164, __pyx_L1_error)
       } else {
-        __pyx_t_4 = PyList_GET_ITEM(sequence, 0); 
-        __pyx_t_2 = PyList_GET_ITEM(sequence, 1); 
+        __pyx_t_1 = __pyx_t_11(__pyx_t_7);
+        if (unlikely(!__pyx_t_1)) {
+          PyObject* exc_type = PyErr_Occurred();
+          if (exc_type) {
+            if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(2, 164, __pyx_L1_error)
+            PyErr_Clear();
+          }
+          break;
+        }
       }
-      __Pyx_INCREF(__pyx_t_4);
-      __Pyx_INCREF(__pyx_t_2);
-      #else
-      __pyx_t_4 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 394, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_1);
+      __pyx_t_1 = 0;
+
+      __pyx_t_8 = NULL;
+      __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_ta_getOutputParameterInfo); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 165, __pyx_L1_error)
       __Pyx_GOTREF(__pyx_t_4);
-      __pyx_t_2 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 394, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_2);
+      __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_Function__name); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 165, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __pyx_t_6 = 1;
+      #if CYTHON_UNPACK_METHODS
+      if (unlikely(PyMethod_Check(__pyx_t_4))) {
+        __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_4);
+        assert(__pyx_t_8);
+        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
+        __Pyx_INCREF(__pyx_t_8);
+        __Pyx_INCREF(__pyx__function);
+        __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
+        __pyx_t_6 = 0;
+      }
       #endif
-      __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
-    } else {
-      Py_ssize_t index = -1;
-      __pyx_t_3 = PyObject_GetIter(__pyx_t_14); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 394, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_3);
-      __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
-      __pyx_t_19 = Py_TYPE(__pyx_t_3)->tp_iternext;
-      index = 0; __pyx_t_4 = __pyx_t_19(__pyx_t_3); if (unlikely(!__pyx_t_4)) goto __pyx_L28_unpacking_failed;
+      {
+        PyObject *__pyx_callargs[3] = {__pyx_t_8, __pyx_t_5, __pyx_v_i};
+        __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+        __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+        if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 165, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_1);
+      }
+      __Pyx_XDECREF_SET(__pyx_v_info, __pyx_t_1);
+      __pyx_t_1 = 0;
+
+      __pyx_t_1 = __Pyx_PyObject_Dict_GetItem(__pyx_v_info, __pyx_mstate_global->__pyx_n_u_name); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 166, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_XDECREF_SET(__pyx_v_output_name, __pyx_t_1);
+      __pyx_t_1 = 0;
+
+      __pyx_t_1 = __Pyx_PyObject_Dict_GetItem(__pyx_v_info, __pyx_mstate_global->__pyx_n_u_flags); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 167, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_info); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 167, __pyx_L1_error)
       __Pyx_GOTREF(__pyx_t_4);
-      index = 1; __pyx_t_2 = __pyx_t_19(__pyx_t_3); if (unlikely(!__pyx_t_2)) goto __pyx_L28_unpacking_failed;
-      __Pyx_GOTREF(__pyx_t_2);
-      if (__Pyx_IternextUnpackEndCheck(__pyx_t_19(__pyx_t_3), 2) < 0) __PYX_ERR(1, 394, __pyx_L1_error)
-      __pyx_t_19 = NULL;
-      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-      goto __pyx_L29_unpacking_done;
-      __pyx_L28_unpacking_failed:;
-      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-      __pyx_t_19 = NULL;
-      if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
-      __PYX_ERR(1, 394, __pyx_L1_error)
-      __pyx_L29_unpacking_done:;
+      __pyx_t_5 = __Pyx_PyObject_Dict_GetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_output_flags); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 167, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      if (unlikely((PyObject_SetItem(__pyx_t_5, __pyx_v_output_name, __pyx_t_1) < 0))) __PYX_ERR(2, 167, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+      __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_outputs); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 168, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      if (unlikely((PyObject_SetItem(__pyx_t_1, __pyx_v_output_name, Py_None) < 0))) __PYX_ERR(2, 168, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
     }
-    __Pyx_XDECREF_SET(__pyx_v_param_name, __pyx_t_4);
-    __pyx_t_4 = 0;
-    __Pyx_XDECREF_SET(__pyx_v_value, __pyx_t_2);
-    __pyx_t_2 = 0;
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
 
-    __pyx_t_14 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__opt_inputs); if (unlikely(!__pyx_t_14)) __PYX_ERR(1, 395, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_14);
-    __pyx_t_2 = __Pyx_PyObject_GetItem(__pyx_t_14, __pyx_v_param_name); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 395, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_2);
-    __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
-    if (unlikely(PyObject_SetItem(__pyx_t_2, __pyx_n_s_value, __pyx_v_value) < 0)) __PYX_ERR(1, 395, __pyx_L1_error)
-    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_output_names); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 169, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_info); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 169, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    if (unlikely((PyObject_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_output_names, __pyx_t_7) < 0))) __PYX_ERR(2, 169, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
 
   }
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_outputs); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 397, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_r = __pyx_t_1;
-  __pyx_t_1 = 0;
+  __Pyx_INCREF(__pyx_v_local);
+  __pyx_r = __pyx_v_local;
   goto __pyx_L0;
 
 
   /* 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_14);
-  __Pyx_XDECREF(__pyx_t_16);
-  __Pyx_XDECREF(__pyx_t_17);
-  __Pyx_XDECREF(__pyx_t_18);
-  __Pyx_AddTraceback("talib._ta_lib.Function.__call__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_XDECREF(__pyx_t_9);
+  __Pyx_AddTraceback("talib._ta_lib.Function.__local", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF(__pyx_v_args);
-  __Pyx_XDECREF(__pyx_v_opt_input_values);
-  __Pyx_XDECREF(__pyx_v_input_arrays);
-  __Pyx_XDECREF(__pyx_v_input_price_series_names);
+  __Pyx_XDECREF(__pyx_v_local);
   __Pyx_XDECREF(__pyx_v_i);
-  __Pyx_XDECREF(__pyx_v_arg);
-  __Pyx_XDECREF(__pyx_v_msg);
+  __Pyx_XDECREF(__pyx_v_info);
+  __Pyx_XDECREF(__pyx_v_input_name);
   __Pyx_XDECREF(__pyx_v_param_name);
-  __Pyx_XDECREF(__pyx_v_value);
+  __Pyx_XDECREF(__pyx_v_output_name);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -35183,164 +41965,248 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_32__call__(CYTHON_UNUSED PyO
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_35__input_price_series_names(PyObject *__pyx_self, PyObject *__pyx_v_self); /*proto*/
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_8Function_35__input_price_series_names = {"__input_price_series_names", (PyCFunction)__pyx_pw_5talib_7_ta_lib_8Function_35__input_price_series_names, METH_O, 0};
-static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_35__input_price_series_names(PyObject *__pyx_self, PyObject *__pyx_v_self) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_5info(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_8Function_4info, "Function.info(self)\n\nReturns a copy of the function's info dict.");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_8Function_5info = {"info", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_8Function_5info, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_8Function_4info};
+static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_5info(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyObject *__pyx_v_self = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__input_price_series_names (wrapper)", 0);
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_8Function_34__input_price_series_names(__pyx_self, ((PyObject *)__pyx_v_self));
+  __Pyx_RefNannySetupContext("info (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(2, 172, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 172, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "info", 0) < (0)) __PYX_ERR(2, 172, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("info", 1, 1, 1, i); __PYX_ERR(2, 172, __pyx_L3_error) }
+      }
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 172, __pyx_L3_error)
+    }
+    __pyx_v_self = values[0];
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("info", 1, 1, 1, __pyx_nargs); __PYX_ERR(2, 172, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.Function.info", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_8Function_4info(__pyx_self, __pyx_v_self);
 
   /* function exit code */
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_34__input_price_series_names(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
-  PyObject *__pyx_v_input_price_series_names = NULL;
-  PyObject *__pyx_v_input_name = NULL;
-  PyObject *__pyx_v_price_series = NULL;
-  PyObject *__pyx_v_name = NULL;
+static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_4info(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   PyObject *__pyx_t_2 = NULL;
-  Py_ssize_t __pyx_t_3;
-  PyObject *(*__pyx_t_4)(PyObject *);
-  PyObject *__pyx_t_5 = NULL;
-  int __pyx_t_6;
-  int __pyx_t_7;
-  Py_ssize_t __pyx_t_8;
-  PyObject *(*__pyx_t_9)(PyObject *);
-  int __pyx_t_10;
-  __Pyx_RefNannySetupContext("__input_price_series_names", 0);
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  size_t __pyx_t_5;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("info", 0);
 
-  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 401, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_v_input_price_series_names = ((PyObject*)__pyx_t_1);
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_Function__local); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 177, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_info); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 177, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_2 = __pyx_t_4;
+  __Pyx_INCREF(__pyx_t_2);
+  __pyx_t_5 = 0;
+  {
+    PyObject *__pyx_callargs[2] = {__pyx_t_2, NULL};
+    __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_copy, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 177, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+  }
+  __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
+  goto __pyx_L0;
 
-  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__input_names); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 402, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (likely(PyList_CheckExact(__pyx_t_1)) || PyTuple_CheckExact(__pyx_t_1)) {
-    __pyx_t_2 = __pyx_t_1; __Pyx_INCREF(__pyx_t_2); __pyx_t_3 = 0;
-    __pyx_t_4 = NULL;
-  } else {
-    __pyx_t_3 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 402, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_2);
-    __pyx_t_4 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 402, __pyx_L1_error)
-  }
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  for (;;) {
-    if (likely(!__pyx_t_4)) {
-      if (likely(PyList_CheckExact(__pyx_t_2))) {
-        if (__pyx_t_3 >= PyList_GET_SIZE(__pyx_t_2)) break;
-        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-        __pyx_t_1 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_1); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(1, 402, __pyx_L1_error)
-        #else
-        __pyx_t_1 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 402, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_1);
-        #endif
-      } else {
-        if (__pyx_t_3 >= PyTuple_GET_SIZE(__pyx_t_2)) break;
-        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-        __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_1); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(1, 402, __pyx_L1_error)
-        #else
-        __pyx_t_1 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 402, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_1);
-        #endif
-      }
-    } else {
-      __pyx_t_1 = __pyx_t_4(__pyx_t_2);
-      if (unlikely(!__pyx_t_1)) {
-        PyObject* exc_type = PyErr_Occurred();
-        if (exc_type) {
-          if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
-          else __PYX_ERR(1, 402, __pyx_L1_error)
-        }
-        break;
-      }
-      __Pyx_GOTREF(__pyx_t_1);
-    }
-    __Pyx_XDECREF_SET(__pyx_v_input_name, __pyx_t_1);
-    __pyx_t_1 = 0;
 
-    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__input_names); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 403, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_1);
-    __pyx_t_5 = __Pyx_PyObject_GetItem(__pyx_t_1, __pyx_v_input_name); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 403, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_5);
-    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-    __pyx_t_1 = __Pyx_PyObject_Dict_GetItem(__pyx_t_5, __pyx_n_s_price_series); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 403, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_1);
-    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-    __Pyx_XDECREF_SET(__pyx_v_price_series, __pyx_t_1);
-    __pyx_t_1 = 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_AddTraceback("talib._ta_lib.Function.info", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
 
-    __pyx_t_6 = PyList_Check(__pyx_v_price_series); 
-    __pyx_t_7 = (__pyx_t_6 != 0);
-    if (__pyx_t_7) {
 
-      if (likely(PyList_CheckExact(__pyx_v_price_series)) || PyTuple_CheckExact(__pyx_v_price_series)) {
-        __pyx_t_1 = __pyx_v_price_series; __Pyx_INCREF(__pyx_t_1); __pyx_t_8 = 0;
-        __pyx_t_9 = NULL;
-      } else {
-        __pyx_t_8 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_v_price_series); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 405, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_1);
-        __pyx_t_9 = Py_TYPE(__pyx_t_1)->tp_iternext; if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 405, __pyx_L1_error)
+/* Python wrapper */
+static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_7function_flags(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_8Function_6function_flags, "Function.function_flags(self)\n\nReturns any function flags defined for this indicator function.");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_8Function_7function_flags = {"function_flags", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_8Function_7function_flags, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_8Function_6function_flags};
+static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_7function_flags(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyObject *__pyx_v_self = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("function_flags (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(2, 179, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 179, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
       }
-      for (;;) {
-        if (likely(!__pyx_t_9)) {
-          if (likely(PyList_CheckExact(__pyx_t_1))) {
-            if (__pyx_t_8 >= PyList_GET_SIZE(__pyx_t_1)) break;
-            #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-            __pyx_t_5 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_8); __Pyx_INCREF(__pyx_t_5); __pyx_t_8++; if (unlikely(0 < 0)) __PYX_ERR(1, 405, __pyx_L1_error)
-            #else
-            __pyx_t_5 = PySequence_ITEM(__pyx_t_1, __pyx_t_8); __pyx_t_8++; if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 405, __pyx_L1_error)
-            __Pyx_GOTREF(__pyx_t_5);
-            #endif
-          } else {
-            if (__pyx_t_8 >= PyTuple_GET_SIZE(__pyx_t_1)) break;
-            #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-            __pyx_t_5 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_8); __Pyx_INCREF(__pyx_t_5); __pyx_t_8++; if (unlikely(0 < 0)) __PYX_ERR(1, 405, __pyx_L1_error)
-            #else
-            __pyx_t_5 = PySequence_ITEM(__pyx_t_1, __pyx_t_8); __pyx_t_8++; if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 405, __pyx_L1_error)
-            __Pyx_GOTREF(__pyx_t_5);
-            #endif
-          }
-        } else {
-          __pyx_t_5 = __pyx_t_9(__pyx_t_1);
-          if (unlikely(!__pyx_t_5)) {
-            PyObject* exc_type = PyErr_Occurred();
-            if (exc_type) {
-              if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
-              else __PYX_ERR(1, 405, __pyx_L1_error)
-            }
-            break;
-          }
-          __Pyx_GOTREF(__pyx_t_5);
-        }
-        __Pyx_XDECREF_SET(__pyx_v_name, __pyx_t_5);
-        __pyx_t_5 = 0;
-
-        __pyx_t_10 = __Pyx_PyList_Append(__pyx_v_input_price_series_names, __pyx_v_name); if (unlikely(__pyx_t_10 == ((int)-1))) __PYX_ERR(1, 406, __pyx_L1_error)
-
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "function_flags", 0) < (0)) __PYX_ERR(2, 179, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("function_flags", 1, 1, 1, i); __PYX_ERR(2, 179, __pyx_L3_error) }
       }
-      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-
-      goto __pyx_L5;
-    }
-
-    /*else*/ {
-      __pyx_t_10 = __Pyx_PyList_Append(__pyx_v_input_price_series_names, __pyx_v_price_series); if (unlikely(__pyx_t_10 == ((int)-1))) __PYX_ERR(1, 408, __pyx_L1_error)
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 179, __pyx_L3_error)
     }
-    __pyx_L5:;
+    __pyx_v_self = values[0];
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("function_flags", 1, 1, 1, __pyx_nargs); __PYX_ERR(2, 179, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.Function.function_flags", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_8Function_6function_flags(__pyx_self, __pyx_v_self);
 
+  /* function exit code */
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
   }
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_6function_flags(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("function_flags", 0);
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(__pyx_v_input_price_series_names);
-  __pyx_r = __pyx_v_input_price_series_names;
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_Function__local); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 184, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_info); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 184, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_PyObject_Dict_GetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_function_flags); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 184, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
   goto __pyx_L0;
 
 
@@ -35348,14 +42214,9 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_34__input_price_series_names
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
   __Pyx_XDECREF(__pyx_t_2);
-  __Pyx_XDECREF(__pyx_t_5);
-  __Pyx_AddTraceback("talib._ta_lib.Function.__input_price_series_names", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.Function.function_flags", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF(__pyx_v_input_price_series_names);
-  __Pyx_XDECREF(__pyx_v_input_name);
-  __Pyx_XDECREF(__pyx_v_price_series);
-  __Pyx_XDECREF(__pyx_v_name);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -35363,393 +42224,364 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_34__input_price_series_names
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_37__call_function(PyObject *__pyx_self, PyObject *__pyx_v_self); /*proto*/
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_8Function_37__call_function = {"__call_function", (PyCFunction)__pyx_pw_5talib_7_ta_lib_8Function_37__call_function, METH_O, 0};
-static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_37__call_function(PyObject *__pyx_self, PyObject *__pyx_v_self) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_9output_flags(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_8Function_8output_flags, "Function.output_flags(self)\n\nReturns the flags for each output for this indicator function.");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_8Function_9output_flags = {"output_flags", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_8Function_9output_flags, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_8Function_8output_flags};
+static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_9output_flags(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyObject *__pyx_v_self = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__call_function (wrapper)", 0);
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_8Function_36__call_function(__pyx_self, ((PyObject *)__pyx_v_self));
+  __Pyx_RefNannySetupContext("output_flags (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(2, 186, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 186, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "output_flags", 0) < (0)) __PYX_ERR(2, 186, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("output_flags", 1, 1, 1, i); __PYX_ERR(2, 186, __pyx_L3_error) }
+      }
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 186, __pyx_L3_error)
+    }
+    __pyx_v_self = values[0];
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("output_flags", 1, 1, 1, __pyx_nargs); __PYX_ERR(2, 186, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.Function.output_flags", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_8Function_8output_flags(__pyx_self, __pyx_v_self);
 
   /* function exit code */
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_36__call_function(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
-  PyObject *__pyx_v_input_price_series_names = NULL;
-  PyObject *__pyx_v_args = NULL;
-  PyObject *__pyx_v_price_series = NULL;
-  PyObject *__pyx_v_series = NULL;
-  PyObject *__pyx_v_opt_input = NULL;
-  PyObject *__pyx_v_value = NULL;
-  PyObject *__pyx_v_results = NULL;
-  PyObject *__pyx_v_keys = NULL;
-  PyObject *__pyx_v_i = NULL;
-  PyObject *__pyx_v_output = NULL;
+static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_8output_flags(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   PyObject *__pyx_t_2 = NULL;
   PyObject *__pyx_t_3 = NULL;
-  Py_ssize_t __pyx_t_4;
-  PyObject *(*__pyx_t_5)(PyObject *);
-  int __pyx_t_6;
-  int __pyx_t_7;
-  int __pyx_t_8;
-  PyObject *__pyx_t_9 = NULL;
-  int __pyx_t_10;
-  __Pyx_RefNannySetupContext("__call_function", 0);
+  PyObject *__pyx_t_4 = NULL;
+  size_t __pyx_t_5;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("output_flags", 0);
 
-  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__input_price_series_na); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 412, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = NULL;
-  if (CYTHON_UNPACK_METHODS && likely(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);
-    }
-  }
-  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2);
-  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
-  if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 412, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __pyx_v_input_price_series_names = __pyx_t_1;
-  __pyx_t_1 = 0;
-
-  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 415, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_v_args = ((PyObject*)__pyx_t_1);
-  __pyx_t_1 = 0;
-
-  if (likely(PyList_CheckExact(__pyx_v_input_price_series_names)) || PyTuple_CheckExact(__pyx_v_input_price_series_names)) {
-    __pyx_t_1 = __pyx_v_input_price_series_names; __Pyx_INCREF(__pyx_t_1); __pyx_t_4 = 0;
-    __pyx_t_5 = NULL;
-  } else {
-    __pyx_t_4 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_v_input_price_series_names); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 416, __pyx_L1_error)
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_Function__local); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 191, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_info); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 191, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_output_flags); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 191, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_2 = __pyx_t_3;
+  __Pyx_INCREF(__pyx_t_2);
+  __pyx_t_5 = 0;
+  {
+    PyObject *__pyx_callargs[2] = {__pyx_t_2, NULL};
+    __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_copy, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 191, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_1);
-    __pyx_t_5 = Py_TYPE(__pyx_t_1)->tp_iternext; if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 416, __pyx_L1_error)
   }
-  for (;;) {
-    if (likely(!__pyx_t_5)) {
-      if (likely(PyList_CheckExact(__pyx_t_1))) {
-        if (__pyx_t_4 >= PyList_GET_SIZE(__pyx_t_1)) break;
-        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-        __pyx_t_2 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_4); __Pyx_INCREF(__pyx_t_2); __pyx_t_4++; if (unlikely(0 < 0)) __PYX_ERR(1, 416, __pyx_L1_error)
-        #else
-        __pyx_t_2 = PySequence_ITEM(__pyx_t_1, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 416, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_2);
-        #endif
-      } else {
-        if (__pyx_t_4 >= PyTuple_GET_SIZE(__pyx_t_1)) break;
-        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-        __pyx_t_2 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_4); __Pyx_INCREF(__pyx_t_2); __pyx_t_4++; if (unlikely(0 < 0)) __PYX_ERR(1, 416, __pyx_L1_error)
-        #else
-        __pyx_t_2 = PySequence_ITEM(__pyx_t_1, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 416, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_2);
-        #endif
-      }
-    } else {
-      __pyx_t_2 = __pyx_t_5(__pyx_t_1);
-      if (unlikely(!__pyx_t_2)) {
-        PyObject* exc_type = PyErr_Occurred();
-        if (exc_type) {
-          if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
-          else __PYX_ERR(1, 416, __pyx_L1_error)
-        }
-        break;
-      }
-      __Pyx_GOTREF(__pyx_t_2);
-    }
-    __Pyx_XDECREF_SET(__pyx_v_price_series, __pyx_t_2);
-    __pyx_t_2 = 0;
-
-    __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__input_arrays); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 417, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_2);
-    __pyx_t_3 = __Pyx_PyObject_GetItem(__pyx_t_2, __pyx_v_price_series); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 417, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_3);
-    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-    __Pyx_XDECREF_SET(__pyx_v_series, __pyx_t_3);
-    __pyx_t_3 = 0;
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
 
-    __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_PANDAS_SERIES); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 418, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_3);
-    __pyx_t_7 = (__pyx_t_3 != Py_None);
-    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-    __pyx_t_8 = (__pyx_t_7 != 0);
-    if (__pyx_t_8) {
-    } else {
-      __pyx_t_6 = __pyx_t_8;
-      goto __pyx_L6_bool_binop_done;
-    }
 
-    __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_PANDAS_SERIES); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 419, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_3);
-    __pyx_t_8 = PyObject_IsInstance(__pyx_v_series, __pyx_t_3); if (unlikely(__pyx_t_8 == ((int)-1))) __PYX_ERR(1, 419, __pyx_L1_error)
-    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-    __pyx_t_7 = (__pyx_t_8 != 0);
-    __pyx_t_6 = __pyx_t_7;
-    __pyx_L6_bool_binop_done:;
+  /* 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("talib._ta_lib.Function.output_flags", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
 
-    if (__pyx_t_6) {
 
-      __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_series, __pyx_n_s_values); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 420, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_2);
-      __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_astype); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 420, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_9);
-      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-      __pyx_t_2 = NULL;
-      if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_9))) {
-        __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_9);
-        if (likely(__pyx_t_2)) {
-          PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_9);
-          __Pyx_INCREF(__pyx_t_2);
-          __Pyx_INCREF(function);
-          __Pyx_DECREF_SET(__pyx_t_9, function);
-        }
+/* Python wrapper */
+static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_11get_input_names(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_8Function_10get_input_names, "Function.get_input_names(self)\n\nReturns the dict of input price series names that specifies which\nof the ndarrays in input_arrays will be used to calculate the function.");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_8Function_11get_input_names = {"get_input_names", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_8Function_11get_input_names, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_8Function_10get_input_names};
+static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_11get_input_names(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyObject *__pyx_v_self = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("get_input_names (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(2, 193, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 193, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
       }
-      __pyx_t_3 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_9, __pyx_t_2, ((PyObject *)(&PyFloat_Type))) : __Pyx_PyObject_CallOneArg(__pyx_t_9, ((PyObject *)(&PyFloat_Type)));
-      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
-      if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 420, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_3);
-      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
-      __Pyx_DECREF_SET(__pyx_v_series, __pyx_t_3);
-      __pyx_t_3 = 0;
-
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "get_input_names", 0) < (0)) __PYX_ERR(2, 193, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("get_input_names", 1, 1, 1, i); __PYX_ERR(2, 193, __pyx_L3_error) }
+      }
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 193, __pyx_L3_error)
     }
+    __pyx_v_self = values[0];
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("get_input_names", 1, 1, 1, __pyx_nargs); __PYX_ERR(2, 193, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.Function.get_input_names", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_8Function_10get_input_names(__pyx_self, __pyx_v_self);
+
+  /* function exit code */
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_10get_input_names(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
+  PyObject *__pyx_v_local = NULL;
+  PyObject *__pyx_v_ret = NULL;
+  PyObject *__pyx_v_input_name = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  size_t __pyx_t_4;
+  Py_ssize_t __pyx_t_5;
+  PyObject *(*__pyx_t_6)(PyObject *);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("get_input_names", 0);
 
-    __pyx_t_10 = __Pyx_PyList_Append(__pyx_v_args, __pyx_v_series); if (unlikely(__pyx_t_10 == ((int)-1))) __PYX_ERR(1, 421, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_Function__local); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 198, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_local = __pyx_t_1;
+  __pyx_t_1 = 0;
 
+  __pyx_t_2 = NULL;
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_OrderedDict); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 199, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = 1;
+  #if CYTHON_UNPACK_METHODS
+  if (unlikely(PyMethod_Check(__pyx_t_3))) {
+    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3);
+    assert(__pyx_t_2);
+    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3);
+    __Pyx_INCREF(__pyx_t_2);
+    __Pyx_INCREF(__pyx__function);
+    __Pyx_DECREF_SET(__pyx_t_3, __pyx__function);
+    __pyx_t_4 = 0;
   }
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  #endif
+  {
+    PyObject *__pyx_callargs[2] = {__pyx_t_2, NULL};
+    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_4, (1-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 199, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+  }
+  __pyx_v_ret = __pyx_t_1;
+  __pyx_t_1 = 0;
 
-  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__opt_inputs); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 422, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_input_names); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 200, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   if (likely(PyList_CheckExact(__pyx_t_1)) || PyTuple_CheckExact(__pyx_t_1)) {
-    __pyx_t_3 = __pyx_t_1; __Pyx_INCREF(__pyx_t_3); __pyx_t_4 = 0;
-    __pyx_t_5 = NULL;
+    __pyx_t_3 = __pyx_t_1; __Pyx_INCREF(__pyx_t_3);
+    __pyx_t_5 = 0;
+    __pyx_t_6 = NULL;
   } else {
-    __pyx_t_4 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 422, __pyx_L1_error)
+    __pyx_t_5 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 200, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_3);
-    __pyx_t_5 = Py_TYPE(__pyx_t_3)->tp_iternext; if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 422, __pyx_L1_error)
+    __pyx_t_6 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 200, __pyx_L1_error)
   }
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   for (;;) {
-    if (likely(!__pyx_t_5)) {
+    if (likely(!__pyx_t_6)) {
       if (likely(PyList_CheckExact(__pyx_t_3))) {
-        if (__pyx_t_4 >= PyList_GET_SIZE(__pyx_t_3)) break;
-        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-        __pyx_t_1 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_4); __Pyx_INCREF(__pyx_t_1); __pyx_t_4++; if (unlikely(0 < 0)) __PYX_ERR(1, 422, __pyx_L1_error)
-        #else
-        __pyx_t_1 = PySequence_ITEM(__pyx_t_3, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 422, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_1);
-        #endif
+        {
+          Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_3);
+          #if !CYTHON_ASSUME_SAFE_SIZE
+          if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 200, __pyx_L1_error)
+          #endif
+          if (__pyx_t_5 >= __pyx_temp) break;
+        }
+        __pyx_t_1 = __Pyx_PyList_GetItemRef(__pyx_t_3, __pyx_t_5);
+        ++__pyx_t_5;
       } else {
-        if (__pyx_t_4 >= PyTuple_GET_SIZE(__pyx_t_3)) break;
+        {
+          Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_3);
+          #if !CYTHON_ASSUME_SAFE_SIZE
+          if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 200, __pyx_L1_error)
+          #endif
+          if (__pyx_t_5 >= __pyx_temp) break;
+        }
         #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-        __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_4); __Pyx_INCREF(__pyx_t_1); __pyx_t_4++; if (unlikely(0 < 0)) __PYX_ERR(1, 422, __pyx_L1_error)
+        __pyx_t_1 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_5));
         #else
-        __pyx_t_1 = PySequence_ITEM(__pyx_t_3, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 422, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_1);
+        __pyx_t_1 = __Pyx_PySequence_ITEM(__pyx_t_3, __pyx_t_5);
         #endif
+        ++__pyx_t_5;
       }
+      if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 200, __pyx_L1_error)
     } else {
-      __pyx_t_1 = __pyx_t_5(__pyx_t_3);
+      __pyx_t_1 = __pyx_t_6(__pyx_t_3);
       if (unlikely(!__pyx_t_1)) {
         PyObject* exc_type = PyErr_Occurred();
         if (exc_type) {
-          if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
-          else __PYX_ERR(1, 422, __pyx_L1_error)
+          if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(2, 200, __pyx_L1_error)
+          PyErr_Clear();
         }
         break;
       }
-      __Pyx_GOTREF(__pyx_t_1);
-    }
-    __Pyx_XDECREF_SET(__pyx_v_opt_input, __pyx_t_1);
-    __pyx_t_1 = 0;
-
-    __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__get_opt_input_value); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 423, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_9);
-    __pyx_t_2 = NULL;
-    if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_9))) {
-      __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_9);
-      if (likely(__pyx_t_2)) {
-        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_9);
-        __Pyx_INCREF(__pyx_t_2);
-        __Pyx_INCREF(function);
-        __Pyx_DECREF_SET(__pyx_t_9, function);
-      }
     }
-    __pyx_t_1 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_9, __pyx_t_2, __pyx_v_opt_input) : __Pyx_PyObject_CallOneArg(__pyx_t_9, __pyx_v_opt_input);
-    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
-    if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 423, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_1);
-    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
-    __Pyx_XDECREF_SET(__pyx_v_value, __pyx_t_1);
+    __Pyx_XDECREF_SET(__pyx_v_input_name, __pyx_t_1);
     __pyx_t_1 = 0;
 
-    __pyx_t_10 = __Pyx_PyList_Append(__pyx_v_args, __pyx_v_value); if (unlikely(__pyx_t_10 == ((int)-1))) __PYX_ERR(1, 424, __pyx_L1_error)
-
-  }
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-
-  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_func_object); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 427, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_1 = PySequence_Tuple(__pyx_v_args); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 427, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_1, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 427, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_9);
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_v_results = __pyx_t_9;
-  __pyx_t_9 = 0;
-
-  __pyx_t_6 = __Pyx_TypeCheck(__pyx_v_results, __pyx_ptype_5numpy_ndarray); 
-  __pyx_t_7 = (__pyx_t_6 != 0);
-  if (__pyx_t_7) {
-
-    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__outputs); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 429, __pyx_L1_error)
+    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_input_names); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 201, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_1);
-    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_keys); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 429, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_2 = __Pyx_PyObject_GetItem(__pyx_t_1, __pyx_v_input_name); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 201, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
     __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-    __pyx_t_1 = NULL;
-    if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
-      __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_3);
-      if (likely(__pyx_t_1)) {
-        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
-        __Pyx_INCREF(__pyx_t_1);
-        __Pyx_INCREF(function);
-        __Pyx_DECREF_SET(__pyx_t_3, function);
-      }
-    }
-    __pyx_t_9 = (__pyx_t_1) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_1) : __Pyx_PyObject_CallNoArg(__pyx_t_3);
-    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
-    if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 429, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_9);
-    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-    __pyx_v_keys = __pyx_t_9;
-    __pyx_t_9 = 0;
-
-    __pyx_t_7 = PyList_Check(__pyx_v_keys); 
-    __pyx_t_6 = ((!(__pyx_t_7 != 0)) != 0);
-    if (__pyx_t_6) {
-
-      __pyx_t_9 = PySequence_List(__pyx_v_keys); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 431, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_9);
-      __Pyx_DECREF_SET(__pyx_v_keys, __pyx_t_9);
-      __pyx_t_9 = 0;
-
-    }
-
-    __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__outputs); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 432, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_9);
-    __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_keys, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 432, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_3);
-    if (unlikely(PyObject_SetItem(__pyx_t_9, __pyx_t_3, __pyx_v_results) < 0)) __PYX_ERR(1, 432, __pyx_L1_error)
-    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
-    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-
-    goto __pyx_L10;
-  }
-
-  /*else*/ {
-    __Pyx_INCREF(__pyx_int_0);
-    __pyx_t_3 = __pyx_int_0;
-    __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__outputs); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 434, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_9);
-    if (likely(PyList_CheckExact(__pyx_t_9)) || PyTuple_CheckExact(__pyx_t_9)) {
-      __pyx_t_1 = __pyx_t_9; __Pyx_INCREF(__pyx_t_1); __pyx_t_4 = 0;
-      __pyx_t_5 = NULL;
-    } else {
-      __pyx_t_4 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_t_9); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 434, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_1);
-      __pyx_t_5 = Py_TYPE(__pyx_t_1)->tp_iternext; if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 434, __pyx_L1_error)
-    }
-    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
-    for (;;) {
-      if (likely(!__pyx_t_5)) {
-        if (likely(PyList_CheckExact(__pyx_t_1))) {
-          if (__pyx_t_4 >= PyList_GET_SIZE(__pyx_t_1)) break;
-          #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-          __pyx_t_9 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_4); __Pyx_INCREF(__pyx_t_9); __pyx_t_4++; if (unlikely(0 < 0)) __PYX_ERR(1, 434, __pyx_L1_error)
-          #else
-          __pyx_t_9 = PySequence_ITEM(__pyx_t_1, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 434, __pyx_L1_error)
-          __Pyx_GOTREF(__pyx_t_9);
-          #endif
-        } else {
-          if (__pyx_t_4 >= PyTuple_GET_SIZE(__pyx_t_1)) break;
-          #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-          __pyx_t_9 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_4); __Pyx_INCREF(__pyx_t_9); __pyx_t_4++; if (unlikely(0 < 0)) __PYX_ERR(1, 434, __pyx_L1_error)
-          #else
-          __pyx_t_9 = PySequence_ITEM(__pyx_t_1, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 434, __pyx_L1_error)
-          __Pyx_GOTREF(__pyx_t_9);
-          #endif
-        }
-      } else {
-        __pyx_t_9 = __pyx_t_5(__pyx_t_1);
-        if (unlikely(!__pyx_t_9)) {
-          PyObject* exc_type = PyErr_Occurred();
-          if (exc_type) {
-            if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
-            else __PYX_ERR(1, 434, __pyx_L1_error)
-          }
-          break;
-        }
-        __Pyx_GOTREF(__pyx_t_9);
-      }
-      __Pyx_XDECREF_SET(__pyx_v_output, __pyx_t_9);
-      __pyx_t_9 = 0;
-      __Pyx_INCREF(__pyx_t_3);
-      __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_3);
-      __pyx_t_9 = __Pyx_PyInt_AddObjC(__pyx_t_3, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 434, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_9);
-      __Pyx_DECREF(__pyx_t_3);
-      __pyx_t_3 = __pyx_t_9;
-      __pyx_t_9 = 0;
-
-      __pyx_t_9 = __Pyx_PyObject_GetItem(__pyx_v_results, __pyx_v_i); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 435, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_9);
-      __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__outputs); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 435, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_2);
-      if (unlikely(PyObject_SetItem(__pyx_t_2, __pyx_v_output, __pyx_t_9) < 0)) __PYX_ERR(1, 435, __pyx_L1_error)
-      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
-
-    }
+    __pyx_t_1 = __Pyx_PyObject_Dict_GetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_price_series); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 201, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    if (unlikely((PyObject_SetItem(__pyx_v_ret, __pyx_v_input_name, __pyx_t_1) < 0))) __PYX_ERR(2, 201, __pyx_L1_error)
     __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
   }
-  __pyx_L10:;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
-  if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_Function__outputs_valid, Py_True) < 0) __PYX_ERR(1, 436, __pyx_L1_error)
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(__pyx_v_ret);
+  __pyx_r = __pyx_v_ret;
+  goto __pyx_L0;
 
 
   /* function exit code */
-  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
-  goto __pyx_L0;
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
   __Pyx_XDECREF(__pyx_t_2);
   __Pyx_XDECREF(__pyx_t_3);
-  __Pyx_XDECREF(__pyx_t_9);
-  __Pyx_AddTraceback("talib._ta_lib.Function.__call_function", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.Function.get_input_names", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF(__pyx_v_input_price_series_names);
-  __Pyx_XDECREF(__pyx_v_args);
-  __Pyx_XDECREF(__pyx_v_price_series);
-  __Pyx_XDECREF(__pyx_v_series);
-  __Pyx_XDECREF(__pyx_v_opt_input);
-  __Pyx_XDECREF(__pyx_v_value);
-  __Pyx_XDECREF(__pyx_v_results);
-  __Pyx_XDECREF(__pyx_v_keys);
-  __Pyx_XDECREF(__pyx_v_i);
-  __Pyx_XDECREF(__pyx_v_output);
+  __Pyx_XDECREF(__pyx_v_local);
+  __Pyx_XDECREF(__pyx_v_ret);
+  __Pyx_XDECREF(__pyx_v_input_name);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -35757,221 +42589,276 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_36__call_function(CYTHON_UNU
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_39__check_opt_input_value(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_8Function_39__check_opt_input_value = {"__check_opt_input_value", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_8Function_39__check_opt_input_value, METH_VARARGS|METH_KEYWORDS, 0};
-static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_39__check_opt_input_value(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_13set_input_names(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_8Function_12set_input_names, "Function.set_input_names(self, input_names)\n\nSets the input price series names to use.");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_8Function_13set_input_names = {"set_input_names", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_8Function_13set_input_names, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_8Function_12set_input_names};
+static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_13set_input_names(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyObject *__pyx_v_self = 0;
-  PyObject *__pyx_v_input_name = 0;
-  PyObject *__pyx_v_value = 0;
+  PyObject *__pyx_v_input_names = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__check_opt_input_value (wrapper)", 0);
+  __Pyx_RefNannySetupContext("set_input_names (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self,&__pyx_n_s_input_name,&__pyx_n_s_value,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);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,&__pyx_mstate_global->__pyx_n_u_input_names,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(2, 204, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(2, 204, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 204, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_self)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_input_name)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("__check_opt_input_value", 1, 3, 3, 1); __PYX_ERR(1, 438, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_value)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("__check_opt_input_value", 1, 3, 3, 2); __PYX_ERR(1, 438, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__check_opt_input_value") < 0)) __PYX_ERR(1, 438, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "set_input_names", 0) < (0)) __PYX_ERR(2, 204, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("set_input_names", 1, 2, 2, i); __PYX_ERR(2, 204, __pyx_L3_error) }
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 3) {
+    } else if (unlikely(__pyx_nargs != 2)) {
       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[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 204, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(2, 204, __pyx_L3_error)
     }
     __pyx_v_self = values[0];
-    __pyx_v_input_name = values[1];
-    __pyx_v_value = values[2];
+    __pyx_v_input_names = values[1];
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("__check_opt_input_value", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 438, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("set_input_names", 1, 2, 2, __pyx_nargs); __PYX_ERR(2, 204, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.Function.__check_opt_input_value", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.Function.set_input_names", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_8Function_38__check_opt_input_value(__pyx_self, __pyx_v_self, __pyx_v_input_name, __pyx_v_value);
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_8Function_12set_input_names(__pyx_self, __pyx_v_self, __pyx_v_input_names);
 
   /* function exit code */
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_38__check_opt_input_value(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_input_name, PyObject *__pyx_v_value) {
-  PyObject *__pyx_v_type_ = NULL;
+static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_12set_input_names(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_input_names) {
+  PyObject *__pyx_v_local = NULL;
+  PyObject *__pyx_v_input_name = NULL;
+  PyObject *__pyx_v_price_series = NULL;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   PyObject *__pyx_t_2 = NULL;
-  int __pyx_t_3;
-  PyObject *__pyx_t_4 = NULL;
-  int __pyx_t_5;
-  __Pyx_RefNannySetupContext("__check_opt_input_value", 0);
+  size_t __pyx_t_3;
+  Py_ssize_t __pyx_t_4;
+  PyObject *(*__pyx_t_5)(PyObject *);
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  PyObject *__pyx_t_8 = NULL;
+  PyObject *(*__pyx_t_9)(PyObject *);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("set_input_names", 0);
 
-  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__opt_inputs); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 439, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = __Pyx_PyObject_GetItem(__pyx_t_1, __pyx_v_input_name); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 439, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_1 = __Pyx_PyObject_Dict_GetItem(__pyx_t_2, __pyx_n_s_type_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 439, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_Function__local); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 208, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __pyx_v_type_ = __pyx_t_1;
+  __pyx_v_local = __pyx_t_1;
   __pyx_t_1 = 0;
 
-  __Pyx_INCREF(__pyx_v_type_);
-  __pyx_t_1 = __pyx_v_type_;
-  __pyx_t_2 = __Pyx_PyInt_From_TA_OptInputParameterType(TA_OptInput_IntegerList); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 440, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_4 = PyObject_RichCompare(__pyx_t_1, __pyx_t_2, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 440, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(1, 440, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  if (!__pyx_t_5) {
-  } else {
-    __pyx_t_3 = __pyx_t_5;
-    goto __pyx_L4_bool_binop_done;
-  }
-  __pyx_t_4 = __Pyx_PyInt_From_TA_OptInputParameterType(TA_OptInput_IntegerRange); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 440, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_4);
-  __pyx_t_2 = PyObject_RichCompare(__pyx_t_1, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 440, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(1, 440, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __pyx_t_3 = __pyx_t_5;
-  __pyx_L4_bool_binop_done:;
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_5 = (__pyx_t_3 != 0);
-  if (__pyx_t_5) {
-
-    __Pyx_INCREF(((PyObject *)(&PyInt_Type)));
-    __Pyx_DECREF_SET(__pyx_v_type_, ((PyObject *)(&PyInt_Type)));
-
-    goto __pyx_L3;
+  __pyx_t_2 = __pyx_v_input_names;
+  __Pyx_INCREF(__pyx_t_2);
+  __pyx_t_3 = 0;
+  {
+    PyObject *__pyx_callargs[2] = {__pyx_t_2, NULL};
+    __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_items, __pyx_callargs+__pyx_t_3, (1-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+    if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 209, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
   }
-
-  __Pyx_INCREF(__pyx_v_type_);
-  __pyx_t_1 = __pyx_v_type_;
-  __pyx_t_2 = __Pyx_PyInt_From_TA_OptInputParameterType(TA_OptInput_RealList); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 442, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_4 = PyObject_RichCompare(__pyx_t_1, __pyx_t_2, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 442, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(1, 442, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  if (!__pyx_t_3) {
+  if (likely(PyList_CheckExact(__pyx_t_1)) || PyTuple_CheckExact(__pyx_t_1)) {
+    __pyx_t_2 = __pyx_t_1; __Pyx_INCREF(__pyx_t_2);
+    __pyx_t_4 = 0;
+    __pyx_t_5 = NULL;
   } else {
-    __pyx_t_5 = __pyx_t_3;
-    goto __pyx_L6_bool_binop_done;
+    __pyx_t_4 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 209, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_t_5 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 209, __pyx_L1_error)
   }
-  __pyx_t_4 = __Pyx_PyInt_From_TA_OptInputParameterType(TA_OptInput_RealRange); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 442, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_4);
-  __pyx_t_2 = PyObject_RichCompare(__pyx_t_1, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 442, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(1, 442, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __pyx_t_5 = __pyx_t_3;
-  __pyx_L6_bool_binop_done:;
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_3 = (__pyx_t_5 != 0);
-  if (__pyx_t_3) {
-
-    __Pyx_INCREF(((PyObject *)(&PyFloat_Type)));
-    __Pyx_DECREF_SET(__pyx_v_type_, ((PyObject *)(&PyFloat_Type)));
-
-  }
-  __pyx_L3:;
-
-  __pyx_t_3 = PyObject_IsInstance(__pyx_v_value, __pyx_v_type_); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 445, __pyx_L1_error)
-  __pyx_t_5 = (__pyx_t_3 != 0);
-  if (__pyx_t_5) {
-
-    __Pyx_XDECREF(__pyx_r);
-    __Pyx_INCREF(Py_True);
-    __pyx_r = Py_True;
-    goto __pyx_L0;
-
-  }
-
-  __pyx_t_5 = (__pyx_v_value != Py_None);
-  __pyx_t_3 = (__pyx_t_5 != 0);
-  if (unlikely(__pyx_t_3)) {
-
-    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_type_, __pyx_n_s_name_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 450, __pyx_L1_error)
+  for (;;) {
+    if (likely(!__pyx_t_5)) {
+      if (likely(PyList_CheckExact(__pyx_t_2))) {
+        {
+          Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_2);
+          #if !CYTHON_ASSUME_SAFE_SIZE
+          if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 209, __pyx_L1_error)
+          #endif
+          if (__pyx_t_4 >= __pyx_temp) break;
+        }
+        __pyx_t_1 = __Pyx_PyList_GetItemRef(__pyx_t_2, __pyx_t_4);
+        ++__pyx_t_4;
+      } else {
+        {
+          Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_2);
+          #if !CYTHON_ASSUME_SAFE_SIZE
+          if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 209, __pyx_L1_error)
+          #endif
+          if (__pyx_t_4 >= __pyx_temp) break;
+        }
+        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+        __pyx_t_1 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_4));
+        #else
+        __pyx_t_1 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_4);
+        #endif
+        ++__pyx_t_4;
+      }
+      if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 209, __pyx_L1_error)
+    } else {
+      __pyx_t_1 = __pyx_t_5(__pyx_t_2);
+      if (unlikely(!__pyx_t_1)) {
+        PyObject* exc_type = PyErr_Occurred();
+        if (exc_type) {
+          if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(2, 209, __pyx_L1_error)
+          PyErr_Clear();
+        }
+        break;
+      }
+    }
     __Pyx_GOTREF(__pyx_t_1);
-    __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)Py_TYPE(__pyx_v_value)), __pyx_n_s_name_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 450, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_2);
-    __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 450, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_4);
-    __Pyx_INCREF(__pyx_v_input_name);
-    __Pyx_GIVEREF(__pyx_v_input_name);
-    PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_v_input_name);
-    __Pyx_GIVEREF(__pyx_t_1);
-    PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_1);
-    __Pyx_GIVEREF(__pyx_t_2);
-    PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_t_2);
-    __pyx_t_1 = 0;
-    __pyx_t_2 = 0;
+    if ((likely(PyTuple_CheckExact(__pyx_t_1))) || (PyList_CheckExact(__pyx_t_1))) {
+      PyObject* sequence = __pyx_t_1;
+      Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
+      if (unlikely(size != 2)) {
+        if (size > 2) __Pyx_RaiseTooManyValuesError(2);
+        else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
+        __PYX_ERR(2, 209, __pyx_L1_error)
+      }
+      #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+      if (likely(PyTuple_CheckExact(sequence))) {
+        __pyx_t_6 = PyTuple_GET_ITEM(sequence, 0);
+        __Pyx_INCREF(__pyx_t_6);
+        __pyx_t_7 = PyTuple_GET_ITEM(sequence, 1);
+        __Pyx_INCREF(__pyx_t_7);
+      } else {
+        __pyx_t_6 = __Pyx_PyList_GetItemRef(sequence, 0);
+        if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 209, __pyx_L1_error)
+        __Pyx_XGOTREF(__pyx_t_6);
+        __pyx_t_7 = __Pyx_PyList_GetItemRef(sequence, 1);
+        if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 209, __pyx_L1_error)
+        __Pyx_XGOTREF(__pyx_t_7);
+      }
+      #else
+      __pyx_t_6 = __Pyx_PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 209, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      __pyx_t_7 = __Pyx_PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 209, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_7);
+      #endif
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    } else {
+      Py_ssize_t index = -1;
+      __pyx_t_8 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 209, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_8);
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+      __pyx_t_9 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_8);
+      index = 0; __pyx_t_6 = __pyx_t_9(__pyx_t_8); if (unlikely(!__pyx_t_6)) goto __pyx_L5_unpacking_failed;
+      __Pyx_GOTREF(__pyx_t_6);
+      index = 1; __pyx_t_7 = __pyx_t_9(__pyx_t_8); if (unlikely(!__pyx_t_7)) goto __pyx_L5_unpacking_failed;
+      __Pyx_GOTREF(__pyx_t_7);
+      if (__Pyx_IternextUnpackEndCheck(__pyx_t_9(__pyx_t_8), 2) < (0)) __PYX_ERR(2, 209, __pyx_L1_error)
+      __pyx_t_9 = NULL;
+      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+      goto __pyx_L6_unpacking_done;
+      __pyx_L5_unpacking_failed:;
+      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+      __pyx_t_9 = NULL;
+      if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
+      __PYX_ERR(2, 209, __pyx_L1_error)
+      __pyx_L6_unpacking_done:;
+    }
+    __Pyx_XDECREF_SET(__pyx_v_input_name, __pyx_t_6);
+    __pyx_t_6 = 0;
+    __Pyx_XDECREF_SET(__pyx_v_price_series, __pyx_t_7);
+    __pyx_t_7 = 0;
 
-    __pyx_t_2 = __Pyx_PyString_Format(__pyx_kp_s_Invalid_parameter_value_for_s_ex, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 449, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_2);
-    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_input_names); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 210, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_t_7 = __Pyx_PyObject_GetItem(__pyx_t_1, __pyx_v_input_name); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 210, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    if (unlikely((PyObject_SetItem(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_price_series, __pyx_v_price_series) < 0))) __PYX_ERR(2, 210, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
 
-    __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_builtin_TypeError, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 448, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_4);
-    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-    __Pyx_Raise(__pyx_t_4, 0, 0, 0);
-    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-    __PYX_ERR(1, 448, __pyx_L1_error)
+    __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_info); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 211, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    __pyx_t_1 = __Pyx_PyObject_Dict_GetItem(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_input_names); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 211, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+    if (unlikely((PyObject_SetItem(__pyx_t_1, __pyx_v_input_name, __pyx_v_price_series) < 0))) __PYX_ERR(2, 211, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   }
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(Py_False);
-  __pyx_r = Py_False;
-  goto __pyx_L0;
+  if (__Pyx_PyObject_SetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_outputs_valid, Py_False) < (0)) __PYX_ERR(2, 212, __pyx_L1_error)
 
 
   /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
   __Pyx_XDECREF(__pyx_t_2);
-  __Pyx_XDECREF(__pyx_t_4);
-  __Pyx_AddTraceback("talib._ta_lib.Function.__check_opt_input_value", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_AddTraceback("talib._ta_lib.Function.set_input_names", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF(__pyx_v_type_);
+  __Pyx_XDECREF(__pyx_v_local);
+  __Pyx_XDECREF(__pyx_v_input_name);
+  __Pyx_XDECREF(__pyx_v_price_series);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -35979,120 +42866,183 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_38__check_opt_input_value(CY
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_41__get_opt_input_value(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_8Function_40__get_opt_input_value[] = "\n        Returns the user-set value if there is one, otherwise the default.\n        ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_8Function_41__get_opt_input_value = {"__get_opt_input_value", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_8Function_41__get_opt_input_value, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_8Function_40__get_opt_input_value};
-static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_41__get_opt_input_value(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_15get_input_arrays(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_8Function_14get_input_arrays, "Function.get_input_arrays(self)\n\nReturns a copy of the dict of input arrays in use.");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_8Function_15get_input_arrays = {"get_input_arrays", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_8Function_15get_input_arrays, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_8Function_14get_input_arrays};
+static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_15get_input_arrays(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyObject *__pyx_v_self = 0;
-  PyObject *__pyx_v_input_name = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__get_opt_input_value (wrapper)", 0);
+  __Pyx_RefNannySetupContext("get_input_arrays (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self,&__pyx_n_s_input_name,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);
-        CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(2, 216, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 216, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_self)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_input_name)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("__get_opt_input_value", 1, 2, 2, 1); __PYX_ERR(1, 453, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__get_opt_input_value") < 0)) __PYX_ERR(1, 453, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "get_input_arrays", 0) < (0)) __PYX_ERR(2, 216, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("get_input_arrays", 1, 1, 1, i); __PYX_ERR(2, 216, __pyx_L3_error) }
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
+    } else if (unlikely(__pyx_nargs != 1)) {
       goto __pyx_L5_argtuple_error;
     } else {
-      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 216, __pyx_L3_error)
     }
     __pyx_v_self = values[0];
-    __pyx_v_input_name = values[1];
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("__get_opt_input_value", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 453, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("get_input_arrays", 1, 1, 1, __pyx_nargs); __PYX_ERR(2, 216, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.Function.__get_opt_input_value", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.Function.get_input_arrays", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_8Function_40__get_opt_input_value(__pyx_self, __pyx_v_self, __pyx_v_input_name);
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_8Function_14get_input_arrays(__pyx_self, __pyx_v_self);
 
   /* function exit code */
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_40__get_opt_input_value(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_input_name) {
-  PyObject *__pyx_v_value = NULL;
+static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_14get_input_arrays(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
+  PyObject *__pyx_v_local = NULL;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  PyObject *__pyx_t_2 = NULL;
+  int __pyx_t_2;
   int __pyx_t_3;
-  int __pyx_t_4;
-  __Pyx_RefNannySetupContext("__get_opt_input_value", 0);
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  size_t __pyx_t_6;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("get_input_arrays", 0);
 
-  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__opt_inputs); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 457, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_Function__local); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 220, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = __Pyx_PyObject_GetItem(__pyx_t_1, __pyx_v_input_name); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 457, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_v_local = __pyx_t_1;
+  __pyx_t_1 = 0;
+
+  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_POLARS_DATAFRAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 221, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_3 = (__pyx_t_1 != Py_None);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_1 = __Pyx_PyObject_Dict_GetItem(__pyx_t_2, __pyx_n_s_value); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 457, __pyx_L1_error)
+  if (__pyx_t_3) {
+  } else {
+    __pyx_t_2 = __pyx_t_3;
+    goto __pyx_L4_bool_binop_done;
+  }
+
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_input_arrays); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 222, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __pyx_v_value = __pyx_t_1;
-  __pyx_t_1 = 0;
+  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_POLARS_DATAFRAME); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 222, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_3 = PyObject_IsInstance(__pyx_t_1, __pyx_t_4); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(2, 222, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_2 = __pyx_t_3;
+  __pyx_L4_bool_binop_done:;
 
-  __pyx_t_3 = (__pyx_v_value == Py_None);
-  __pyx_t_4 = (__pyx_t_3 != 0);
-  if (__pyx_t_4) {
+  if (__pyx_t_2) {
 
-    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_Function__opt_inputs); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 459, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_1);
-    __pyx_t_2 = __Pyx_PyObject_GetItem(__pyx_t_1, __pyx_v_input_name); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 459, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_2);
-    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-    __pyx_t_1 = __Pyx_PyObject_Dict_GetItem(__pyx_t_2, __pyx_n_s_default_value); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 459, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_1);
-    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-    __Pyx_DECREF_SET(__pyx_v_value, __pyx_t_1);
-    __pyx_t_1 = 0;
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_input_arrays); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 223, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __pyx_t_1 = __pyx_t_5;
+    __Pyx_INCREF(__pyx_t_1);
+    __pyx_t_6 = 0;
+    {
+      PyObject *__pyx_callargs[2] = {__pyx_t_1, NULL};
+      __pyx_t_4 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_clone, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+      __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 223, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+    }
+    __pyx_r = __pyx_t_4;
+    __pyx_t_4 = 0;
+    goto __pyx_L0;
 
   }
 
-  __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(__pyx_v_value);
-  __pyx_r = __pyx_v_value;
-  goto __pyx_L0;
+  /*else*/ {
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_input_arrays); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 225, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_t_5 = __pyx_t_1;
+    __Pyx_INCREF(__pyx_t_5);
+    __pyx_t_6 = 0;
+    {
+      PyObject *__pyx_callargs[2] = {__pyx_t_5, NULL};
+      __pyx_t_4 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_copy, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+      if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 225, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+    }
+    __pyx_r = __pyx_t_4;
+    __pyx_t_4 = 0;
+    goto __pyx_L0;
+  }
 
 
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_XDECREF(__pyx_t_2);
-  __Pyx_AddTraceback("talib._ta_lib.Function.__get_opt_input_value", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_AddTraceback("talib._ta_lib.Function.get_input_arrays", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF(__pyx_v_value);
+  __Pyx_XDECREF(__pyx_v_local);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -36100,244 +43050,336 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_40__get_opt_input_value(CYTH
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_43__repr__(PyObject *__pyx_self, PyObject *__pyx_v_self); /*proto*/
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_8Function_43__repr__ = {"__repr__", (PyCFunction)__pyx_pw_5talib_7_ta_lib_8Function_43__repr__, METH_O, 0};
-static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_43__repr__(PyObject *__pyx_self, PyObject *__pyx_v_self) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_17set_input_arrays(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_8Function_16set_input_arrays, "Function.set_input_arrays(self, input_arrays)\n\nSets the dict of input_arrays to use. Returns True/False for\nsubclasses:\n\nIf input_arrays is a dict with the keys open, high, low, close and\nvolume, it is assigned as the input_array to use and this function\nreturns True, returning False otherwise. If you implement your own\ndata type and wish to subclass Function, you should wrap this function\nwith an if-statement:\n\nclass CustomFunction(Function):\n    def __init__(self, function_name):\n        Function.__init__(self, function_name)\n\n    def set_input_arrays(self, input_data):\n        if Function.set_input_arrays(self, input_data):\n            return True\n        elif isinstance(input_data, some_module.CustomDataType):\n            input_arrays = Function.get_input_arrays(self)\n            # convert input_data to input_arrays and then call the super\n            Function.set_input_arrays(self, input_arrays)\n            return True\n        return False");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_8Function_17set_input_arrays = {"set_input_arrays", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_8Function_17set_input_arrays, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_8Function_16set_input_arrays};
+static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_17set_input_arrays(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyObject *__pyx_v_self = 0;
+  PyObject *__pyx_v_input_arrays = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0);
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_8Function_42__repr__(__pyx_self, ((PyObject *)__pyx_v_self));
+  __Pyx_RefNannySetupContext("set_input_arrays (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,&__pyx_mstate_global->__pyx_n_u_input_arrays,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(2, 227, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(2, 227, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 227, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "set_input_arrays", 0) < (0)) __PYX_ERR(2, 227, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("set_input_arrays", 1, 2, 2, i); __PYX_ERR(2, 227, __pyx_L3_error) }
+      }
+    } else if (unlikely(__pyx_nargs != 2)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 227, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(2, 227, __pyx_L3_error)
+    }
+    __pyx_v_self = values[0];
+    __pyx_v_input_arrays = values[1];
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("set_input_arrays", 1, 2, 2, __pyx_nargs); __PYX_ERR(2, 227, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.Function.set_input_arrays", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_8Function_16set_input_arrays(__pyx_self, __pyx_v_self, __pyx_v_input_arrays);
 
   /* function exit code */
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_42__repr__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_16set_input_arrays(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_input_arrays) {
+  PyObject *__pyx_v_local = NULL;
+  PyObject *__pyx_v_missing_keys = NULL;
+  PyObject *__pyx_v_key = NULL;
+  PyObject *__pyx_v_missing = NULL;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  PyObject *__pyx_t_2 = NULL;
-  __Pyx_RefNannySetupContext("__repr__", 0);
+  int __pyx_t_2;
+  PyObject *__pyx_t_3 = NULL;
+  size_t __pyx_t_4;
+  Py_ssize_t __pyx_t_5;
+  PyObject *(*__pyx_t_6)(PyObject *);
+  int __pyx_t_7;
+  int __pyx_t_8;
+  PyObject *__pyx_t_9 = NULL;
+  PyObject *__pyx_t_10 = NULL;
+  PyObject *__pyx_t_11 = NULL;
+  PyObject *__pyx_t_12[4];
+  PyObject *__pyx_t_13 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("set_input_arrays", 0);
 
-  __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_info); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 463, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_Function__local); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 252, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = __Pyx_PyString_FormatSafe(__pyx_kp_s_s_2, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 463, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_r = __pyx_t_2;
-  __pyx_t_2 = 0;
-  goto __pyx_L0;
-
+  __pyx_v_local = __pyx_t_1;
+  __pyx_t_1 = 0;
 
-  /* function exit code */
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_XDECREF(__pyx_t_2);
-  __Pyx_AddTraceback("talib._ta_lib.Function.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = NULL;
-  __pyx_L0:;
-  __Pyx_XGIVEREF(__pyx_r);
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
+  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_INPUT_ARRAYS_TYPES); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 253, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = PyObject_IsInstance(__pyx_v_input_arrays, __pyx_t_1); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(2, 253, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  if (__pyx_t_2) {
 
+    __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 254, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_v_missing_keys = ((PyObject*)__pyx_t_1);
+    __pyx_t_1 = 0;
 
-/* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_45__unicode__(PyObject *__pyx_self, PyObject *__pyx_v_self); /*proto*/
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_8Function_45__unicode__ = {"__unicode__", (PyCFunction)__pyx_pw_5talib_7_ta_lib_8Function_45__unicode__, METH_O, 0};
-static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_45__unicode__(PyObject *__pyx_self, PyObject *__pyx_v_self) {
-  PyObject *__pyx_r = 0;
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__unicode__ (wrapper)", 0);
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_8Function_44__unicode__(__pyx_self, ((PyObject *)__pyx_v_self));
+    __pyx_t_3 = __pyx_v_self;
+    __Pyx_INCREF(__pyx_t_3);
+    __pyx_t_4 = 0;
+    {
+      PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL};
+      __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_Function__input_price_series_na, __pyx_callargs+__pyx_t_4, (1-__pyx_t_4) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+      if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 255, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+    }
+    if (likely(PyList_CheckExact(__pyx_t_1)) || PyTuple_CheckExact(__pyx_t_1)) {
+      __pyx_t_3 = __pyx_t_1; __Pyx_INCREF(__pyx_t_3);
+      __pyx_t_5 = 0;
+      __pyx_t_6 = NULL;
+    } else {
+      __pyx_t_5 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 255, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __pyx_t_6 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 255, __pyx_L1_error)
+    }
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    for (;;) {
+      if (likely(!__pyx_t_6)) {
+        if (likely(PyList_CheckExact(__pyx_t_3))) {
+          {
+            Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_3);
+            #if !CYTHON_ASSUME_SAFE_SIZE
+            if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 255, __pyx_L1_error)
+            #endif
+            if (__pyx_t_5 >= __pyx_temp) break;
+          }
+          __pyx_t_1 = __Pyx_PyList_GetItemRef(__pyx_t_3, __pyx_t_5);
+          ++__pyx_t_5;
+        } else {
+          {
+            Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_3);
+            #if !CYTHON_ASSUME_SAFE_SIZE
+            if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 255, __pyx_L1_error)
+            #endif
+            if (__pyx_t_5 >= __pyx_temp) break;
+          }
+          #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+          __pyx_t_1 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_5));
+          #else
+          __pyx_t_1 = __Pyx_PySequence_ITEM(__pyx_t_3, __pyx_t_5);
+          #endif
+          ++__pyx_t_5;
+        }
+        if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 255, __pyx_L1_error)
+      } else {
+        __pyx_t_1 = __pyx_t_6(__pyx_t_3);
+        if (unlikely(!__pyx_t_1)) {
+          PyObject* exc_type = PyErr_Occurred();
+          if (exc_type) {
+            if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(2, 255, __pyx_L1_error)
+            PyErr_Clear();
+          }
+          break;
+        }
+      }
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_XDECREF_SET(__pyx_v_key, __pyx_t_1);
+      __pyx_t_1 = 0;
 
-  /* function exit code */
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
+      __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_POLARS_DATAFRAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 256, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __pyx_t_7 = (__pyx_t_1 != Py_None);
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+      if (__pyx_t_7) {
+      } else {
+        __pyx_t_2 = __pyx_t_7;
+        goto __pyx_L7_bool_binop_done;
+      }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_44__unicode__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
-  PyObject *__pyx_r = NULL;
-  __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
-  PyObject *__pyx_t_2 = NULL;
-  PyObject *__pyx_t_3 = NULL;
-  __Pyx_RefNannySetupContext("__unicode__", 0);
+      __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_POLARS_DATAFRAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 257, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __pyx_t_7 = PyObject_IsInstance(__pyx_v_input_arrays, __pyx_t_1); if (unlikely(__pyx_t_7 == ((int)-1))) __PYX_ERR(2, 257, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+      __pyx_t_2 = __pyx_t_7;
+      __pyx_L7_bool_binop_done:;
 
-  __Pyx_XDECREF(__pyx_r);
-  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_str); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 466, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = NULL;
-  if (CYTHON_UNPACK_METHODS && likely(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);
-    }
-  }
-  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2);
-  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
-  if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 466, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __pyx_t_2 = __Pyx_PyObject_Unicode(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 466, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_r = __pyx_t_2;
-  __pyx_t_2 = 0;
-  goto __pyx_L0;
+      if (__pyx_t_2) {
 
+        __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_input_arrays, __pyx_mstate_global->__pyx_n_u_columns); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 258, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_1);
+        __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_v_key, __pyx_t_1, Py_NE)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(2, 258, __pyx_L1_error)
+        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+        __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 258, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_1);
+        __Pyx_XDECREF_SET(__pyx_v_missing, __pyx_t_1);
+        __pyx_t_1 = 0;
 
-  /* function exit code */
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_XDECREF(__pyx_t_2);
-  __Pyx_XDECREF(__pyx_t_3);
-  __Pyx_AddTraceback("talib._ta_lib.Function.__unicode__", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = NULL;
-  __pyx_L0:;
-  __Pyx_XGIVEREF(__pyx_r);
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
+        goto __pyx_L6;
+      }
 
+      /*else*/ {
+        __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_v_key, __pyx_v_input_arrays, Py_NE)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(2, 260, __pyx_L1_error)
+        __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 260, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_1);
+        __Pyx_XDECREF_SET(__pyx_v_missing, __pyx_t_1);
+        __pyx_t_1 = 0;
+      }
+      __pyx_L6:;
 
-/* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_47__str__(PyObject *__pyx_self, PyObject *__pyx_v_self); /*proto*/
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_8Function_47__str__ = {"__str__", (PyCFunction)__pyx_pw_5talib_7_ta_lib_8Function_47__str__, METH_O, 0};
-static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_47__str__(PyObject *__pyx_self, PyObject *__pyx_v_self) {
-  PyObject *__pyx_r = 0;
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__str__ (wrapper)", 0);
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_8Function_46__str__(__pyx_self, ((PyObject *)__pyx_v_self));
+      __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_missing); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(2, 261, __pyx_L1_error)
+      if (__pyx_t_2) {
 
-  /* function exit code */
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
+        __pyx_t_8 = __Pyx_PyList_Append(__pyx_v_missing_keys, __pyx_v_key); if (unlikely(__pyx_t_8 == ((int)-1))) __PYX_ERR(2, 262, __pyx_L1_error)
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_46__str__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
-  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("__str__", 0);
+      }
 
-  __Pyx_XDECREF(__pyx_r);
-  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_get_defaults_and_docs); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 469, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_info); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 469, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __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);
     }
-  }
-  __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3);
-  __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 469, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __pyx_t_2 = __Pyx_GetItemInt(__pyx_t_1, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 469, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_r = __pyx_t_2;
-  __pyx_t_2 = 0;
-  goto __pyx_L0;
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
+    __pyx_t_5 = __Pyx_PyList_GET_SIZE(__pyx_v_missing_keys); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(2, 263, __pyx_L1_error)
+    __pyx_t_2 = (__pyx_t_5 == 0);
+    if (likely(__pyx_t_2)) {
 
-  /* 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("talib._ta_lib.Function.__str__", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = NULL;
-  __pyx_L0:;
-  __Pyx_XGIVEREF(__pyx_r);
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
+      if (__Pyx_PyObject_SetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_input_arrays, __pyx_v_input_arrays) < (0)) __PYX_ERR(2, 264, __pyx_L1_error)
 
+      if (__Pyx_PyObject_SetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_outputs_valid, Py_False) < (0)) __PYX_ERR(2, 265, __pyx_L1_error)
 
-/* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_343_ta_getGroupTable(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_342_ta_getGroupTable[] = "\n    Returns the list of available TALIB function group names. *slow*\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_343_ta_getGroupTable = {"_ta_getGroupTable", (PyCFunction)__pyx_pw_5talib_7_ta_lib_343_ta_getGroupTable, METH_NOARGS, __pyx_doc_5talib_7_ta_lib_342_ta_getGroupTable};
-static PyObject *__pyx_pw_5talib_7_ta_lib_343_ta_getGroupTable(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused) {
-  PyObject *__pyx_r = 0;
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("_ta_getGroupTable (wrapper)", 0);
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_342_ta_getGroupTable(__pyx_self);
+      __Pyx_XDECREF(__pyx_r);
+      __Pyx_INCREF(Py_True);
+      __pyx_r = Py_True;
+      goto __pyx_L0;
 
-  /* function exit code */
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
+    }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_342_ta_getGroupTable(CYTHON_UNUSED PyObject *__pyx_self) {
-  TA_StringTable *__pyx_v_table;
-  PyObject *__pyx_v_groups = NULL;
-  unsigned int __pyx_v_i;
-  PyObject *__pyx_r = NULL;
-  __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
-  unsigned int __pyx_t_2;
-  unsigned int __pyx_t_3;
-  unsigned int __pyx_t_4;
-  int __pyx_t_5;
-  __Pyx_RefNannySetupContext("_ta_getGroupTable", 0);
+    /*else*/ {
+      __pyx_t_1 = NULL;
+      __Pyx_INCREF((PyObject *)(((PyTypeObject*)PyExc_Exception)));
+      __pyx_t_9 = ((PyObject *)(((PyTypeObject*)PyExc_Exception))); 
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_GroupTableAlloc, TA_GroupTableAlloc((&__pyx_v_table)), 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 487, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+      __pyx_t_5 = __Pyx_PyList_GET_SIZE(__pyx_v_missing_keys); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(2, 269, __pyx_L1_error)
+      __pyx_t_2 = (__pyx_t_5 > 1);
+      if (__pyx_t_2) {
+        __Pyx_INCREF(__pyx_mstate_global->__pyx_n_u_s);
+        __pyx_t_10 = __pyx_mstate_global->__pyx_n_u_s;
+      } else {
+        __Pyx_INCREF(__pyx_mstate_global->__pyx_kp_u__2);
+        __pyx_t_10 = __pyx_mstate_global->__pyx_kp_u__2;
+      }
+      __pyx_t_11 = __Pyx_PyUnicode_Unicode(__pyx_t_10); if (unlikely(!__pyx_t_11)) __PYX_ERR(2, 269, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_11);
+      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
 
-  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 488, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_v_groups = ((PyObject*)__pyx_t_1);
-  __pyx_t_1 = 0;
+      __pyx_t_10 = PyUnicode_Join(__pyx_mstate_global->__pyx_kp_u__3, __pyx_v_missing_keys); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 271, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_10);
+      __pyx_t_12[0] = __pyx_mstate_global->__pyx_kp_u_input_arrays_parameter_missing_r;
+      __pyx_t_12[1] = __pyx_t_11;
+      __pyx_t_12[2] = __pyx_mstate_global->__pyx_kp_u_;
+      __pyx_t_12[3] = __pyx_t_10;
 
-  __pyx_t_2 = __pyx_v_table->size;
-  __pyx_t_3 = __pyx_t_2;
-  for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) {
-    __pyx_v_i = __pyx_t_4;
+      __pyx_t_13 = __Pyx_PyUnicode_Join(__pyx_t_12, 4, 48 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_11) + 2 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_10), 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_11) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_10));
+      if (unlikely(!__pyx_t_13)) __PYX_ERR(2, 268, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_13);
+      __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+      __pyx_t_4 = 1;
+      {
+        PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_t_13};
+        __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_9, __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+        __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+        __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+        if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 268, __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(2, 268, __pyx_L1_error)
+    }
 
-    __pyx_t_1 = __Pyx_PyBytes_FromString((*(&(__pyx_v_table->string[__pyx_v_i])))); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 490, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_1);
-    __pyx_t_5 = __Pyx_PyList_Append(__pyx_v_groups, __pyx_t_1); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(1, 490, __pyx_L1_error)
-    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   }
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_GroupTableFree, TA_GroupTableFree(__pyx_v_table), 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 491, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(__pyx_v_groups);
-  __pyx_r = __pyx_v_groups;
+  __Pyx_INCREF(Py_False);
+  __pyx_r = Py_False;
   goto __pyx_L0;
 
 
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib._ta_getGroupTable", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_9);
+  __Pyx_XDECREF(__pyx_t_10);
+  __Pyx_XDECREF(__pyx_t_11);
+  __Pyx_XDECREF(__pyx_t_13);
+  __Pyx_AddTraceback("talib._ta_lib.Function.set_input_arrays", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF(__pyx_v_groups);
+  __Pyx_XDECREF(__pyx_v_local);
+  __Pyx_XDECREF(__pyx_v_missing_keys);
+  __Pyx_XDECREF(__pyx_v_key);
+  __Pyx_XDECREF(__pyx_v_missing);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -36345,80 +43387,227 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_342_ta_getGroupTable(CYTHON_UNUSED PyO
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_345_ta_getFuncTable(PyObject *__pyx_self, PyObject *__pyx_arg_group); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_344_ta_getFuncTable[] = "\n    Returns a list of the functions for the specified group name. *slow*\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_345_ta_getFuncTable = {"_ta_getFuncTable", (PyCFunction)__pyx_pw_5talib_7_ta_lib_345_ta_getFuncTable, METH_O, __pyx_doc_5talib_7_ta_lib_344_ta_getFuncTable};
-static PyObject *__pyx_pw_5talib_7_ta_lib_345_ta_getFuncTable(PyObject *__pyx_self, PyObject *__pyx_arg_group) {
-  char *__pyx_v_group;
+static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_19get_parameters(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_8Function_18get_parameters, "Function.get_parameters(self)\n\nReturns the function's optional parameters and their default values.");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_8Function_19get_parameters = {"get_parameters", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_8Function_19get_parameters, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_8Function_18get_parameters};
+static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_19get_parameters(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyObject *__pyx_v_self = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("_ta_getFuncTable (wrapper)", 0);
-  assert(__pyx_arg_group); {
-    __pyx_v_group = __Pyx_PyObject_AsWritableString(__pyx_arg_group); if (unlikely((!__pyx_v_group) && PyErr_Occurred())) __PYX_ERR(1, 494, __pyx_L3_error)
+  __Pyx_RefNannySetupContext("get_parameters (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(2, 276, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 276, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "get_parameters", 0) < (0)) __PYX_ERR(2, 276, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("get_parameters", 1, 1, 1, i); __PYX_ERR(2, 276, __pyx_L3_error) }
+      }
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 276, __pyx_L3_error)
+    }
+    __pyx_v_self = values[0];
   }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("get_parameters", 1, 1, 1, __pyx_nargs); __PYX_ERR(2, 276, __pyx_L3_error)
+  __pyx_L6_skip:;
   goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib._ta_getFuncTable", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.Function.get_parameters", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_344_ta_getFuncTable(__pyx_self, ((char *)__pyx_v_group));
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_8Function_18get_parameters(__pyx_self, __pyx_v_self);
 
   /* function exit code */
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_344_ta_getFuncTable(CYTHON_UNUSED PyObject *__pyx_self, char *__pyx_v_group) {
-  TA_StringTable *__pyx_v_table;
-  PyObject *__pyx_v_functions = NULL;
-  unsigned int __pyx_v_i;
+static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_18get_parameters(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
+  PyObject *__pyx_v_local = NULL;
+  PyObject *__pyx_v_ret = NULL;
+  PyObject *__pyx_v_opt_input = NULL;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  unsigned int __pyx_t_2;
-  unsigned int __pyx_t_3;
-  unsigned int __pyx_t_4;
-  int __pyx_t_5;
-  __Pyx_RefNannySetupContext("_ta_getFuncTable", 0);
-
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_FuncTableAlloc, TA_FuncTableAlloc(__pyx_v_group, (&__pyx_v_table)), 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 499, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  size_t __pyx_t_4;
+  Py_ssize_t __pyx_t_5;
+  PyObject *(*__pyx_t_6)(PyObject *);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("get_parameters", 0);
 
-  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 500, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_Function__local); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 280, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_v_functions = ((PyObject*)__pyx_t_1);
+  __pyx_v_local = __pyx_t_1;
   __pyx_t_1 = 0;
 
-  __pyx_t_2 = __pyx_v_table->size;
-  __pyx_t_3 = __pyx_t_2;
-  for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) {
-    __pyx_v_i = __pyx_t_4;
-
-    __pyx_t_1 = __Pyx_PyBytes_FromString((*(&(__pyx_v_table->string[__pyx_v_i])))); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 502, __pyx_L1_error)
+  __pyx_t_2 = NULL;
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_OrderedDict); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 281, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = 1;
+  #if CYTHON_UNPACK_METHODS
+  if (unlikely(PyMethod_Check(__pyx_t_3))) {
+    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3);
+    assert(__pyx_t_2);
+    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3);
+    __Pyx_INCREF(__pyx_t_2);
+    __Pyx_INCREF(__pyx__function);
+    __Pyx_DECREF_SET(__pyx_t_3, __pyx__function);
+    __pyx_t_4 = 0;
+  }
+  #endif
+  {
+    PyObject *__pyx_callargs[2] = {__pyx_t_2, NULL};
+    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_4, (1-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 281, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_1);
-    __pyx_t_5 = __Pyx_PyList_Append(__pyx_v_functions, __pyx_t_1); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(1, 502, __pyx_L1_error)
-    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   }
+  __pyx_v_ret = __pyx_t_1;
+  __pyx_t_1 = 0;
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_FuncTableFree, TA_FuncTableFree(__pyx_v_table), 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 503, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_opt_inputs); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 282, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
+  if (likely(PyList_CheckExact(__pyx_t_1)) || PyTuple_CheckExact(__pyx_t_1)) {
+    __pyx_t_3 = __pyx_t_1; __Pyx_INCREF(__pyx_t_3);
+    __pyx_t_5 = 0;
+    __pyx_t_6 = NULL;
+  } else {
+    __pyx_t_5 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 282, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_6 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 282, __pyx_L1_error)
+  }
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  for (;;) {
+    if (likely(!__pyx_t_6)) {
+      if (likely(PyList_CheckExact(__pyx_t_3))) {
+        {
+          Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_3);
+          #if !CYTHON_ASSUME_SAFE_SIZE
+          if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 282, __pyx_L1_error)
+          #endif
+          if (__pyx_t_5 >= __pyx_temp) break;
+        }
+        __pyx_t_1 = __Pyx_PyList_GetItemRef(__pyx_t_3, __pyx_t_5);
+        ++__pyx_t_5;
+      } else {
+        {
+          Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_3);
+          #if !CYTHON_ASSUME_SAFE_SIZE
+          if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 282, __pyx_L1_error)
+          #endif
+          if (__pyx_t_5 >= __pyx_temp) break;
+        }
+        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+        __pyx_t_1 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_5));
+        #else
+        __pyx_t_1 = __Pyx_PySequence_ITEM(__pyx_t_3, __pyx_t_5);
+        #endif
+        ++__pyx_t_5;
+      }
+      if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 282, __pyx_L1_error)
+    } else {
+      __pyx_t_1 = __pyx_t_6(__pyx_t_3);
+      if (unlikely(!__pyx_t_1)) {
+        PyObject* exc_type = PyErr_Occurred();
+        if (exc_type) {
+          if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(2, 282, __pyx_L1_error)
+          PyErr_Clear();
+        }
+        break;
+      }
+    }
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_XDECREF_SET(__pyx_v_opt_input, __pyx_t_1);
+    __pyx_t_1 = 0;
+
+    __pyx_t_2 = __pyx_v_self;
+    __Pyx_INCREF(__pyx_t_2);
+    __pyx_t_4 = 0;
+    {
+      PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_v_opt_input};
+      __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_Function__get_opt_input_value, __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+      if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 283, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+    }
+    if (unlikely((PyObject_SetItem(__pyx_v_ret, __pyx_v_opt_input, __pyx_t_1) < 0))) __PYX_ERR(2, 283, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  }
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(__pyx_v_functions);
-  __pyx_r = __pyx_v_functions;
+  __Pyx_INCREF(__pyx_v_ret);
+  __pyx_r = __pyx_v_ret;
   goto __pyx_L0;
 
 
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib._ta_getFuncTable", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("talib._ta_lib.Function.get_parameters", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF(__pyx_v_functions);
+  __Pyx_XDECREF(__pyx_v_local);
+  __Pyx_XDECREF(__pyx_v_ret);
+  __Pyx_XDECREF(__pyx_v_opt_input);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -36426,593 +43615,335 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_344_ta_getFuncTable(CYTHON_UNUSED PyOb
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_347__get_flags(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_346__get_flags[] = "\n    TA-LIB provides hints for multiple flags as a bitwise-ORed int.\n    This function returns the flags from flag found in the provided\n    flags_lookup_dict.\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_347__get_flags = {"__get_flags", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_347__get_flags, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_346__get_flags};
-static PyObject *__pyx_pw_5talib_7_ta_lib_347__get_flags(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  int __pyx_v_flag;
-  PyObject *__pyx_v_flags_lookup_dict = 0;
+static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_21set_parameters(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_8Function_20set_parameters, "Function.set_parameters(self, parameters=None, **kwargs)\n\nSets the function parameter values.");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_8Function_21set_parameters = {"set_parameters", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_8Function_21set_parameters, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_8Function_20set_parameters};
+static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_21set_parameters(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyObject *__pyx_v_self = 0;
+  PyObject *__pyx_v_parameters = 0;
+  PyObject *__pyx_v_kwargs = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__get_flags (wrapper)", 0);
+  __Pyx_RefNannySetupContext("set_parameters (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  __pyx_v_kwargs = PyDict_New(); if (unlikely(!__pyx_v_kwargs)) return NULL;
+  __Pyx_GOTREF(__pyx_v_kwargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_flag,&__pyx_n_s_flags_lookup_dict,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);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,&__pyx_mstate_global->__pyx_n_u_parameters,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(2, 286, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(2, 286, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 286, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_flag)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, __pyx_v_kwargs, values, kwd_pos_args, __pyx_kwds_len, "set_parameters", 1) < (0)) __PYX_ERR(2, 286, __pyx_L3_error)
+      if (!values[1]) values[1] = __Pyx_NewRef(((PyObject *)Py_None));
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("set_parameters", 0, 1, 2, i); __PYX_ERR(2, 286, __pyx_L3_error) }
+      }
+    } else {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(2, 286, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_flags_lookup_dict)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("__get_flags", 1, 2, 2, 1); __PYX_ERR(1, 506, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__get_flags") < 0)) __PYX_ERR(1, 506, __pyx_L3_error)
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 286, __pyx_L3_error)
+        break;
+        default: goto __pyx_L5_argtuple_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);
+      if (!values[1]) values[1] = __Pyx_NewRef(((PyObject *)Py_None));
     }
-    __pyx_v_flag = __Pyx_PyInt_As_int(values[0]); if (unlikely((__pyx_v_flag == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 506, __pyx_L3_error)
-    __pyx_v_flags_lookup_dict = ((PyObject*)values[1]);
+    __pyx_v_self = values[0];
+    __pyx_v_parameters = values[1];
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("__get_flags", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 506, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("set_parameters", 0, 1, 2, __pyx_nargs); __PYX_ERR(2, 286, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.__get_flags", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __Pyx_RefNannyFinishContext();
-  return NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_DECREF(__pyx_v_kwargs); __pyx_v_kwargs = 0;
+  __Pyx_AddTraceback("talib._ta_lib.Function.set_parameters", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_flags_lookup_dict), (&PyDict_Type), 1, "flags_lookup_dict", 1))) __PYX_ERR(1, 506, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_346__get_flags(__pyx_self, __pyx_v_flag, __pyx_v_flags_lookup_dict);
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_8Function_20set_parameters(__pyx_self, __pyx_v_self, __pyx_v_parameters, __pyx_v_kwargs);
 
   /* function exit code */
-  goto __pyx_L0;
-  __pyx_L1_error:;
-  __pyx_r = NULL;
-  __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_DECREF(__pyx_v_kwargs);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_346__get_flags(CYTHON_UNUSED PyObject *__pyx_self, int __pyx_v_flag, PyObject *__pyx_v_flags_lookup_dict) {
-  PyObject *__pyx_v_value_range = NULL;
-  PyObject *__pyx_v_min_int = NULL;
-  PyObject *__pyx_v_max_int = NULL;
-  PyObject *__pyx_v_ret = NULL;
-  PyObject *__pyx_v_i = NULL;
+static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_20set_parameters(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_parameters, PyObject *__pyx_v_kwargs) {
+  PyObject *__pyx_v_local = NULL;
+  PyObject *__pyx_v_param = NULL;
+  PyObject *__pyx_v_value = NULL;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   int __pyx_t_2;
-  int __pyx_t_3;
-  PyObject *__pyx_t_4 = NULL;
-  PyObject *__pyx_t_5 = NULL;
-  PyObject *__pyx_t_6 = NULL;
-  int __pyx_t_7;
+  PyObject *__pyx_t_3 = NULL;
+  size_t __pyx_t_4;
+  Py_ssize_t __pyx_t_5;
+  PyObject *(*__pyx_t_6)(PyObject *);
+  PyObject *__pyx_t_7 = NULL;
   PyObject *__pyx_t_8 = NULL;
-  Py_ssize_t __pyx_t_9;
+  PyObject *__pyx_t_9 = NULL;
   PyObject *(*__pyx_t_10)(PyObject *);
-  int __pyx_t_11;
-  __Pyx_RefNannySetupContext("__get_flags", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("set_parameters", 0);
+  __Pyx_INCREF(__pyx_v_parameters);
 
-  if (unlikely(__pyx_v_flags_lookup_dict == Py_None)) {
-    PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "keys");
-    __PYX_ERR(1, 512, __pyx_L1_error)
-  }
-  __pyx_t_1 = __Pyx_PyDict_Keys(__pyx_v_flags_lookup_dict); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 512, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_Function__local); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 290, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_v_value_range = __pyx_t_1;
+  __pyx_v_local = __pyx_t_1;
   __pyx_t_1 = 0;
 
-  __pyx_t_2 = PyList_Check(__pyx_v_value_range); 
-  __pyx_t_3 = ((!(__pyx_t_2 != 0)) != 0);
-  if (__pyx_t_3) {
-
-    __pyx_t_1 = PySequence_List(__pyx_v_value_range); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 514, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_1);
-    __Pyx_DECREF_SET(__pyx_v_value_range, __pyx_t_1);
-    __pyx_t_1 = 0;
-
+  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_parameters); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(2, 291, __pyx_L1_error)
+  if (!__pyx_t_2) {
+  } else {
+    __Pyx_INCREF(__pyx_v_parameters);
+    __pyx_t_1 = __pyx_v_parameters;
+    goto __pyx_L3_bool_binop_done;
   }
+  __pyx_t_3 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 291, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_INCREF(__pyx_t_3);
+  __pyx_t_1 = __pyx_t_3;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_L3_bool_binop_done:;
+  __Pyx_DECREF_SET(__pyx_v_parameters, __pyx_t_1);
+  __pyx_t_1 = 0;
 
-  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_math); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 515, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_4);
-  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_log); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 515, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_5);
-  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_builtin_min, __pyx_v_value_range); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 515, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_4);
-  __pyx_t_6 = NULL;
-  __pyx_t_7 = 0;
-  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);
-      __pyx_t_7 = 1;
-    }
-  }
-  #if CYTHON_FAST_PYCALL
-  if (PyFunction_Check(__pyx_t_5)) {
-    PyObject *__pyx_temp[3] = {__pyx_t_6, __pyx_t_4, __pyx_int_2};
-    __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 515, __pyx_L1_error)
-    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
-    __Pyx_GOTREF(__pyx_t_1);
-    __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[3] = {__pyx_t_6, __pyx_t_4, __pyx_int_2};
-    __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 515, __pyx_L1_error)
-    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
-    __Pyx_GOTREF(__pyx_t_1);
-    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  } else
-  #endif
+  __pyx_t_3 = __pyx_v_parameters;
+  __Pyx_INCREF(__pyx_t_3);
+  __pyx_t_4 = 0;
   {
-    __pyx_t_8 = PyTuple_New(2+__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 515, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_8);
-    if (__pyx_t_6) {
-      __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_6); __pyx_t_6 = NULL;
-    }
-    __Pyx_GIVEREF(__pyx_t_4);
-    PyTuple_SET_ITEM(__pyx_t_8, 0+__pyx_t_7, __pyx_t_4);
-    __Pyx_INCREF(__pyx_int_2);
-    __Pyx_GIVEREF(__pyx_int_2);
-    PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_7, __pyx_int_2);
-    __pyx_t_4 = 0;
-    __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_8, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 515, __pyx_L1_error)
+    PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_kwargs};
+    __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_update, __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+    if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 292, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_1);
-    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
   }
-  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-  __pyx_t_5 = __Pyx_PyNumber_Int(__pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 515, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_5);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_v_min_int = __pyx_t_5;
-  __pyx_t_5 = 0;
 
-  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_math); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 516, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_log); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 516, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_8);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_builtin_max, __pyx_v_value_range); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 516, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_4 = NULL;
-  __pyx_t_7 = 0;
-  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_8))) {
-    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_8);
-    if (likely(__pyx_t_4)) {
-      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8);
-      __Pyx_INCREF(__pyx_t_4);
-      __Pyx_INCREF(function);
-      __Pyx_DECREF_SET(__pyx_t_8, function);
-      __pyx_t_7 = 1;
-    }
-  }
-  #if CYTHON_FAST_PYCALL
-  if (PyFunction_Check(__pyx_t_8)) {
-    PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_t_1, __pyx_int_2};
-    __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_8, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 516, __pyx_L1_error)
-    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
-    __Pyx_GOTREF(__pyx_t_5);
-    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  } else
-  #endif
-  #if CYTHON_FAST_PYCCALL
-  if (__Pyx_PyFastCFunction_Check(__pyx_t_8)) {
-    PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_t_1, __pyx_int_2};
-    __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_8, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 516, __pyx_L1_error)
-    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
-    __Pyx_GOTREF(__pyx_t_5);
-    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  } else
-  #endif
+  __pyx_t_3 = __pyx_v_parameters;
+  __Pyx_INCREF(__pyx_t_3);
+  __pyx_t_4 = 0;
   {
-    __pyx_t_6 = PyTuple_New(2+__pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 516, __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_1);
-    PyTuple_SET_ITEM(__pyx_t_6, 0+__pyx_t_7, __pyx_t_1);
-    __Pyx_INCREF(__pyx_int_2);
-    __Pyx_GIVEREF(__pyx_int_2);
-    PyTuple_SET_ITEM(__pyx_t_6, 1+__pyx_t_7, __pyx_int_2);
-    __pyx_t_1 = 0;
-    __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_6, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 516, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_5);
-    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
-  }
-  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
-  __pyx_t_8 = __Pyx_PyNumber_Int(__pyx_t_5); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 516, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_8);
-  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-  __pyx_v_max_int = __pyx_t_8;
-  __pyx_t_8 = 0;
-
-  __pyx_t_2 = ((__pyx_v_flag < 1) != 0);
-  if (!__pyx_t_2) {
-  } else {
-    __pyx_t_3 = __pyx_t_2;
-    goto __pyx_L5_bool_binop_done;
-  }
-  __pyx_t_8 = __Pyx_PyInt_From_int(__pyx_v_flag); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 519, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_8);
-  __pyx_t_5 = __Pyx_PyNumber_PowerOf2(__pyx_int_2, __pyx_v_max_int, Py_None); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 519, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_5);
-  __pyx_t_6 = PyObject_RichCompare(__pyx_t_8, __pyx_t_5, Py_GT); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 519, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
-  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(1, 519, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
-  __pyx_t_3 = __pyx_t_2;
-  __pyx_L5_bool_binop_done:;
-  if (__pyx_t_3) {
-
-    __Pyx_XDECREF(__pyx_r);
-    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
-    goto __pyx_L0;
-
+    PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL};
+    __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_items, __pyx_callargs+__pyx_t_4, (1-__pyx_t_4) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+    if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 293, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
   }
-
-  __pyx_t_6 = PyList_New(0); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 525, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_6);
-  __pyx_v_ret = ((PyObject*)__pyx_t_6);
-  __pyx_t_6 = 0;
-
-  __pyx_t_6 = __Pyx_PyInt_AddObjC(__pyx_v_max_int, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 526, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_6);
-  __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 526, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_5);
-  __Pyx_INCREF(__pyx_v_min_int);
-  __Pyx_GIVEREF(__pyx_v_min_int);
-  PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_v_min_int);
-  __Pyx_GIVEREF(__pyx_t_6);
-  PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_6);
-  __pyx_t_6 = 0;
-  __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_xrange, __pyx_t_5, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 526, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_6);
-  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-  if (likely(PyList_CheckExact(__pyx_t_6)) || PyTuple_CheckExact(__pyx_t_6)) {
-    __pyx_t_5 = __pyx_t_6; __Pyx_INCREF(__pyx_t_5); __pyx_t_9 = 0;
-    __pyx_t_10 = NULL;
+  if (likely(PyList_CheckExact(__pyx_t_1)) || PyTuple_CheckExact(__pyx_t_1)) {
+    __pyx_t_3 = __pyx_t_1; __Pyx_INCREF(__pyx_t_3);
+    __pyx_t_5 = 0;
+    __pyx_t_6 = NULL;
   } else {
-    __pyx_t_9 = -1; __pyx_t_5 = PyObject_GetIter(__pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 526, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_5);
-    __pyx_t_10 = Py_TYPE(__pyx_t_5)->tp_iternext; if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 526, __pyx_L1_error)
+    __pyx_t_5 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 293, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_6 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 293, __pyx_L1_error)
   }
-  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   for (;;) {
-    if (likely(!__pyx_t_10)) {
-      if (likely(PyList_CheckExact(__pyx_t_5))) {
-        if (__pyx_t_9 >= PyList_GET_SIZE(__pyx_t_5)) break;
-        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-        __pyx_t_6 = PyList_GET_ITEM(__pyx_t_5, __pyx_t_9); __Pyx_INCREF(__pyx_t_6); __pyx_t_9++; if (unlikely(0 < 0)) __PYX_ERR(1, 526, __pyx_L1_error)
-        #else
-        __pyx_t_6 = PySequence_ITEM(__pyx_t_5, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 526, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_6);
-        #endif
+    if (likely(!__pyx_t_6)) {
+      if (likely(PyList_CheckExact(__pyx_t_3))) {
+        {
+          Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_3);
+          #if !CYTHON_ASSUME_SAFE_SIZE
+          if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 293, __pyx_L1_error)
+          #endif
+          if (__pyx_t_5 >= __pyx_temp) break;
+        }
+        __pyx_t_1 = __Pyx_PyList_GetItemRef(__pyx_t_3, __pyx_t_5);
+        ++__pyx_t_5;
       } else {
-        if (__pyx_t_9 >= PyTuple_GET_SIZE(__pyx_t_5)) break;
+        {
+          Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_3);
+          #if !CYTHON_ASSUME_SAFE_SIZE
+          if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 293, __pyx_L1_error)
+          #endif
+          if (__pyx_t_5 >= __pyx_temp) break;
+        }
         #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-        __pyx_t_6 = PyTuple_GET_ITEM(__pyx_t_5, __pyx_t_9); __Pyx_INCREF(__pyx_t_6); __pyx_t_9++; if (unlikely(0 < 0)) __PYX_ERR(1, 526, __pyx_L1_error)
+        __pyx_t_1 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_5));
         #else
-        __pyx_t_6 = PySequence_ITEM(__pyx_t_5, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 526, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_6);
+        __pyx_t_1 = __Pyx_PySequence_ITEM(__pyx_t_3, __pyx_t_5);
         #endif
+        ++__pyx_t_5;
       }
+      if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 293, __pyx_L1_error)
     } else {
-      __pyx_t_6 = __pyx_t_10(__pyx_t_5);
-      if (unlikely(!__pyx_t_6)) {
+      __pyx_t_1 = __pyx_t_6(__pyx_t_3);
+      if (unlikely(!__pyx_t_1)) {
         PyObject* exc_type = PyErr_Occurred();
         if (exc_type) {
-          if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
-          else __PYX_ERR(1, 526, __pyx_L1_error)
+          if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(2, 293, __pyx_L1_error)
+          PyErr_Clear();
         }
         break;
       }
-      __Pyx_GOTREF(__pyx_t_6);
     }
-    __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_6);
-    __pyx_t_6 = 0;
-
-    __pyx_t_6 = __Pyx_PyNumber_PowerOf2(__pyx_int_2, __pyx_v_i, Py_None); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 527, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_6);
-    __pyx_t_8 = __Pyx_PyInt_From_int(__pyx_v_flag); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 527, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_8);
-    __pyx_t_1 = PyNumber_And(__pyx_t_6, __pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 527, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_1);
-    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
-    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
-    __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(1, 527, __pyx_L1_error)
-    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-    if (__pyx_t_3) {
-
-      if (unlikely(__pyx_v_flags_lookup_dict == Py_None)) {
-        PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
-        __PYX_ERR(1, 528, __pyx_L1_error)
+    if ((likely(PyTuple_CheckExact(__pyx_t_1))) || (PyList_CheckExact(__pyx_t_1))) {
+      PyObject* sequence = __pyx_t_1;
+      Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
+      if (unlikely(size != 2)) {
+        if (size > 2) __Pyx_RaiseTooManyValuesError(2);
+        else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
+        __PYX_ERR(2, 293, __pyx_L1_error)
       }
-      __pyx_t_1 = __Pyx_PyNumber_PowerOf2(__pyx_int_2, __pyx_v_i, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 528, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_1);
-      __pyx_t_8 = __Pyx_PyDict_GetItem(__pyx_v_flags_lookup_dict, __pyx_t_1); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 528, __pyx_L1_error)
+      #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+      if (likely(PyTuple_CheckExact(sequence))) {
+        __pyx_t_7 = PyTuple_GET_ITEM(sequence, 0);
+        __Pyx_INCREF(__pyx_t_7);
+        __pyx_t_8 = PyTuple_GET_ITEM(sequence, 1);
+        __Pyx_INCREF(__pyx_t_8);
+      } else {
+        __pyx_t_7 = __Pyx_PyList_GetItemRef(sequence, 0);
+        if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 293, __pyx_L1_error)
+        __Pyx_XGOTREF(__pyx_t_7);
+        __pyx_t_8 = __Pyx_PyList_GetItemRef(sequence, 1);
+        if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 293, __pyx_L1_error)
+        __Pyx_XGOTREF(__pyx_t_8);
+      }
+      #else
+      __pyx_t_7 = __Pyx_PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 293, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_7);
+      __pyx_t_8 = __Pyx_PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 293, __pyx_L1_error)
       __Pyx_GOTREF(__pyx_t_8);
+      #endif
       __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-      __pyx_t_11 = __Pyx_PyList_Append(__pyx_v_ret, __pyx_t_8); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(1, 528, __pyx_L1_error)
-      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
-
+    } else {
+      Py_ssize_t index = -1;
+      __pyx_t_9 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 293, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_9);
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+      __pyx_t_10 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_9);
+      index = 0; __pyx_t_7 = __pyx_t_10(__pyx_t_9); if (unlikely(!__pyx_t_7)) goto __pyx_L7_unpacking_failed;
+      __Pyx_GOTREF(__pyx_t_7);
+      index = 1; __pyx_t_8 = __pyx_t_10(__pyx_t_9); if (unlikely(!__pyx_t_8)) goto __pyx_L7_unpacking_failed;
+      __Pyx_GOTREF(__pyx_t_8);
+      if (__Pyx_IternextUnpackEndCheck(__pyx_t_10(__pyx_t_9), 2) < (0)) __PYX_ERR(2, 293, __pyx_L1_error)
+      __pyx_t_10 = NULL;
+      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+      goto __pyx_L8_unpacking_done;
+      __pyx_L7_unpacking_failed:;
+      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+      __pyx_t_10 = NULL;
+      if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
+      __PYX_ERR(2, 293, __pyx_L1_error)
+      __pyx_L8_unpacking_done:;
     }
+    __Pyx_XDECREF_SET(__pyx_v_param, __pyx_t_7);
+    __pyx_t_7 = 0;
+    __Pyx_XDECREF_SET(__pyx_v_value, __pyx_t_8);
+    __pyx_t_8 = 0;
 
-  }
-  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-
-  __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(__pyx_v_ret);
-  __pyx_r = __pyx_v_ret;
-  goto __pyx_L0;
-
-
-  /* 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_XDECREF(__pyx_t_8);
-  __Pyx_AddTraceback("talib._ta_lib.__get_flags", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = NULL;
-  __pyx_L0:;
-  __Pyx_XDECREF(__pyx_v_value_range);
-  __Pyx_XDECREF(__pyx_v_min_int);
-  __Pyx_XDECREF(__pyx_v_max_int);
-  __Pyx_XDECREF(__pyx_v_ret);
-  __Pyx_XDECREF(__pyx_v_i);
-  __Pyx_XGIVEREF(__pyx_r);
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-
-/* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_349_ta_getFuncInfo(PyObject *__pyx_self, PyObject *__pyx_arg_function_name); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_348_ta_getFuncInfo[] = "\n    Returns the info dict for the function. It has the following keys: name,\n    group, help, flags, num_inputs, num_opt_inputs and num_outputs.\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_349_ta_getFuncInfo = {"_ta_getFuncInfo", (PyCFunction)__pyx_pw_5talib_7_ta_lib_349_ta_getFuncInfo, METH_O, __pyx_doc_5talib_7_ta_lib_348_ta_getFuncInfo};
-static PyObject *__pyx_pw_5talib_7_ta_lib_349_ta_getFuncInfo(PyObject *__pyx_self, PyObject *__pyx_arg_function_name) {
-  char *__pyx_v_function_name;
-  PyObject *__pyx_r = 0;
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("_ta_getFuncInfo (wrapper)", 0);
-  assert(__pyx_arg_function_name); {
-    __pyx_v_function_name = __Pyx_PyObject_AsWritableString(__pyx_arg_function_name); if (unlikely((!__pyx_v_function_name) && PyErr_Occurred())) __PYX_ERR(1, 565, __pyx_L3_error)
-  }
-  goto __pyx_L4_argument_unpacking_done;
-  __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib._ta_getFuncInfo", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __Pyx_RefNannyFinishContext();
-  return NULL;
-  __pyx_L4_argument_unpacking_done:;
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_348_ta_getFuncInfo(__pyx_self, ((char *)__pyx_v_function_name));
-
-  /* function exit code */
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-static PyObject *__pyx_pf_5talib_7_ta_lib_348_ta_getFuncInfo(CYTHON_UNUSED PyObject *__pyx_self, char *__pyx_v_function_name) {
-  TA_FuncInfo *__pyx_v_info;
-  TA_RetCode __pyx_v_retCode;
-  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;
-  PyObject *__pyx_t_6 = NULL;
-  int __pyx_t_7;
-  PyObject *__pyx_t_8 = NULL;
-  __Pyx_RefNannySetupContext("_ta_getFuncInfo", 0);
-
-  __pyx_v_retCode = TA_GetFuncInfo(__pyx_f_5talib_7_ta_lib___ta_getFuncHandle(__pyx_v_function_name), (&__pyx_v_info));
-
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_GetFuncInfo, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 572, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-
-  __Pyx_XDECREF(__pyx_r);
-
-  __pyx_t_1 = __Pyx_PyDict_NewPresized(7); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 575, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_bytes2str); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 575, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = __Pyx_PyBytes_FromString(__pyx_v_info->name); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 575, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_4);
-  __pyx_t_5 = NULL;
-  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
-    __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3);
-    if (likely(__pyx_t_5)) {
-      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
-      __Pyx_INCREF(__pyx_t_5);
-      __Pyx_INCREF(function);
-      __Pyx_DECREF_SET(__pyx_t_3, function);
+    __pyx_t_8 = __pyx_v_self;
+    __Pyx_INCREF(__pyx_t_8);
+    __pyx_t_4 = 0;
+    {
+      PyObject *__pyx_callargs[3] = {__pyx_t_8, __pyx_v_param, __pyx_v_value};
+      __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_Function__check_opt_input_value, __pyx_callargs+__pyx_t_4, (3-__pyx_t_4) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+      __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+      if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 294, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
     }
-  }
-  __pyx_t_2 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_5, __pyx_t_4) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4);
-  __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
-  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 575, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_name, __pyx_t_2) < 0) __PYX_ERR(1, 575, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(2, 294, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    if (__pyx_t_2) {
 
-  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_bytes2str); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 576, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = __Pyx_PyBytes_FromString(__pyx_v_info->group); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 576, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_4);
-  __pyx_t_5 = NULL;
-  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
-    __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3);
-    if (likely(__pyx_t_5)) {
-      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
-      __Pyx_INCREF(__pyx_t_5);
-      __Pyx_INCREF(function);
-      __Pyx_DECREF_SET(__pyx_t_3, function);
-    }
-  }
-  __pyx_t_2 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_5, __pyx_t_4) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4);
-  __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
-  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 576, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_group, __pyx_t_2) < 0) __PYX_ERR(1, 575, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_opt_inputs); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 295, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __pyx_t_8 = __Pyx_PyObject_GetItem(__pyx_t_1, __pyx_v_param); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 295, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_8);
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+      if (unlikely((PyObject_SetItem(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_value, __pyx_v_value) < 0))) __PYX_ERR(2, 295, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
 
-  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_bytes2str); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 577, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = __Pyx_PyBytes_FromString(__pyx_v_info->hint); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 577, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_4);
-  __pyx_t_5 = NULL;
-  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
-    __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3);
-    if (likely(__pyx_t_5)) {
-      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
-      __Pyx_INCREF(__pyx_t_5);
-      __Pyx_INCREF(function);
-      __Pyx_DECREF_SET(__pyx_t_3, function);
     }
-  }
-  __pyx_t_2 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_5, __pyx_t_4) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4);
-  __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
-  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 577, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_display_name, __pyx_t_2) < 0) __PYX_ERR(1, 575, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_get_flags); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 578, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = __Pyx_PyInt_From_TA_FuncFlags(__pyx_v_info->flags); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 578, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_4);
-  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_TA_FUNC_FLAGS); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 578, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_5);
-  __pyx_t_6 = NULL;
-  __pyx_t_7 = 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_7 = 1;
-    }
-  }
-  #if CYTHON_FAST_PYCALL
-  if (PyFunction_Check(__pyx_t_3)) {
-    PyObject *__pyx_temp[3] = {__pyx_t_6, __pyx_t_4, __pyx_t_5};
-    __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 578, __pyx_L1_error)
-    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
-    __Pyx_GOTREF(__pyx_t_2);
-    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 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[3] = {__pyx_t_6, __pyx_t_4, __pyx_t_5};
-    __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 578, __pyx_L1_error)
-    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
-    __Pyx_GOTREF(__pyx_t_2);
-    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-  } else
-  #endif
-  {
-    __pyx_t_8 = PyTuple_New(2+__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 578, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_8);
-    if (__pyx_t_6) {
-      __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_6); __pyx_t_6 = NULL;
-    }
-    __Pyx_GIVEREF(__pyx_t_4);
-    PyTuple_SET_ITEM(__pyx_t_8, 0+__pyx_t_7, __pyx_t_4);
-    __Pyx_GIVEREF(__pyx_t_5);
-    PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_7, __pyx_t_5);
-    __pyx_t_4 = 0;
-    __pyx_t_5 = 0;
-    __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_8, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 578, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_2);
-    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
   }
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_function_flags, __pyx_t_2) < 0) __PYX_ERR(1, 575, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-
-  __pyx_t_2 = __Pyx_PyInt_From_unsigned_int(__pyx_v_info->nbInput); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 579, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = __Pyx_PyObject_CallOneArg(((PyObject *)(&PyInt_Type)), __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 579, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_num_inputs, __pyx_t_3) < 0) __PYX_ERR(1, 575, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
-  __pyx_t_3 = __Pyx_PyInt_From_unsigned_int(__pyx_v_info->nbOptInput); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 580, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_2 = __Pyx_PyObject_CallOneArg(((PyObject *)(&PyInt_Type)), __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 580, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_num_opt_inputs, __pyx_t_2) < 0) __PYX_ERR(1, 575, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  if (__Pyx_PyObject_SetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_outputs_valid, Py_False) < (0)) __PYX_ERR(2, 296, __pyx_L1_error)
 
-  __pyx_t_2 = __Pyx_PyInt_From_unsigned_int(__pyx_v_info->nbOutput); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 581, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = __Pyx_PyObject_CallOneArg(((PyObject *)(&PyInt_Type)), __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 581, __pyx_L1_error)
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_parameters); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 297, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_num_outputs, __pyx_t_3) < 0) __PYX_ERR(1, 575, __pyx_L1_error)
+  __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_info); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 297, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_8);
+  if (unlikely((PyObject_SetItem(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_parameters, __pyx_t_3) < 0))) __PYX_ERR(2, 297, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __pyx_r = __pyx_t_1;
-  __pyx_t_1 = 0;
-  goto __pyx_L0;
 
 
   /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
   __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_6);
+  __Pyx_XDECREF(__pyx_t_7);
   __Pyx_XDECREF(__pyx_t_8);
-  __Pyx_AddTraceback("talib._ta_lib._ta_getFuncInfo", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_XDECREF(__pyx_t_9);
+  __Pyx_AddTraceback("talib._ta_lib.Function.set_parameters", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_local);
+  __Pyx_XDECREF(__pyx_v_param);
+  __Pyx_XDECREF(__pyx_v_value);
+  __Pyx_XDECREF(__pyx_v_parameters);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -37020,246 +43951,442 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_348_ta_getFuncInfo(CYTHON_UNUSED PyObj
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_351_ta_getInputParameterInfo(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_350_ta_getInputParameterInfo[] = "\n    Returns the function's input info dict for the given index. It has two\n    keys: name and flags.\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_351_ta_getInputParameterInfo = {"_ta_getInputParameterInfo", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_351_ta_getInputParameterInfo, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_350_ta_getInputParameterInfo};
-static PyObject *__pyx_pw_5talib_7_ta_lib_351_ta_getInputParameterInfo(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  char *__pyx_v_function_name;
-  int __pyx_v_idx;
+static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_23set_function_args(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_8Function_22set_function_args, "Function.set_function_args(self, *args, **kwargs)\n\noptional args:[input_arrays,] [parameter_args,] [input_price_series_kwargs,] [parameter_kwargs]");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_8Function_23set_function_args = {"set_function_args", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_8Function_23set_function_args, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_8Function_22set_function_args};
+static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_23set_function_args(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyObject *__pyx_v_self = 0;
+  PyObject *__pyx_v_args = 0;
+  PyObject *__pyx_v_kwargs = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("_ta_getInputParameterInfo (wrapper)", 0);
+  __Pyx_RefNannySetupContext("set_function_args (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  __pyx_v_kwargs = PyDict_New(); if (unlikely(!__pyx_v_kwargs)) return NULL;
+  __Pyx_GOTREF(__pyx_v_kwargs);
+  __pyx_v_args = __Pyx_ArgsSlice_FASTCALL(__pyx_args, 1, __pyx_nargs);
+  if (unlikely(!__pyx_v_args)) {
+    __Pyx_DECREF(__pyx_v_kwargs); __pyx_v_kwargs = 0;
+    __Pyx_RefNannyFinishContext();
+    return NULL;
+  }
+  __Pyx_GOTREF(__pyx_v_args);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_function_name,&__pyx_n_s_idx,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);
-        CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(2, 301, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        default:
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 301, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
-        default: goto __pyx_L5_argtuple_error;
-      }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_function_name)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_idx)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("_ta_getInputParameterInfo", 1, 2, 2, 1); __PYX_ERR(1, 584, __pyx_L3_error)
-        }
       }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "_ta_getInputParameterInfo") < 0)) __PYX_ERR(1, 584, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      const Py_ssize_t used_pos_args = (kwd_pos_args < 1) ? kwd_pos_args : 1;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, __pyx_v_kwargs, values, used_pos_args, __pyx_kwds_len, "set_function_args", 1) < (0)) __PYX_ERR(2, 301, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("set_function_args", 0, 1, 1, i); __PYX_ERR(2, 301, __pyx_L3_error) }
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
+    } else if (unlikely(__pyx_nargs < 1)) {
       goto __pyx_L5_argtuple_error;
     } else {
-      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 301, __pyx_L3_error)
     }
-    __pyx_v_function_name = __Pyx_PyObject_AsWritableString(values[0]); if (unlikely((!__pyx_v_function_name) && PyErr_Occurred())) __PYX_ERR(1, 584, __pyx_L3_error)
-    __pyx_v_idx = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_idx == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 584, __pyx_L3_error)
+    __pyx_v_self = values[0];
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("_ta_getInputParameterInfo", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 584, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("set_function_args", 0, 1, 1, __pyx_nargs); __PYX_ERR(2, 301, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib._ta_getInputParameterInfo", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_DECREF(__pyx_v_args); __pyx_v_args = 0;
+  __Pyx_DECREF(__pyx_v_kwargs); __pyx_v_kwargs = 0;
+  __Pyx_AddTraceback("talib._ta_lib.Function.set_function_args", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_350_ta_getInputParameterInfo(__pyx_self, __pyx_v_function_name, __pyx_v_idx);
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_8Function_22set_function_args(__pyx_self, __pyx_v_self, __pyx_v_args, __pyx_v_kwargs);
 
   /* function exit code */
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_DECREF(__pyx_v_args);
+  __Pyx_DECREF(__pyx_v_kwargs);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_350_ta_getInputParameterInfo(CYTHON_UNUSED PyObject *__pyx_self, char *__pyx_v_function_name, int __pyx_v_idx) {
-  TA_InputParameterInfo *__pyx_v_info;
-  TA_RetCode __pyx_v_retCode;
-  PyObject *__pyx_v_name = NULL;
+static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_22set_function_args(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_args, PyObject *__pyx_v_kwargs) {
+  PyObject *__pyx_v_local = NULL;
+  int __pyx_v_update_info;
+  PyObject *__pyx_v_key = NULL;
+  PyObject *__pyx_v_value = NULL;
+  PyObject *__pyx_v_skip_first = NULL;
+  PyObject *__pyx_v_i = NULL;
+  PyObject *__pyx_v_param_name = 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;
-  Py_ssize_t __pyx_t_5;
+  Py_ssize_t __pyx_t_2;
+  Py_ssize_t __pyx_t_3;
+  int __pyx_t_4;
+  PyObject *__pyx_t_5 = NULL;
   int __pyx_t_6;
   int __pyx_t_7;
   PyObject *__pyx_t_8 = NULL;
-  PyObject *__pyx_t_9 = NULL;
-  int __pyx_t_10;
-  PyObject *__pyx_t_11 = NULL;
-  __Pyx_RefNannySetupContext("_ta_getInputParameterInfo", 0);
-
-  __pyx_v_retCode = TA_GetInputParameterInfo(__pyx_f_5talib_7_ta_lib___ta_getFuncHandle(__pyx_v_function_name), __pyx_v_idx, (&__pyx_v_info));
-
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_GetInputParameterInfo, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 591, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-
-  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_bytes2str); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 593, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = __Pyx_PyBytes_FromString(__pyx_v_info->paramName); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 593, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __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);
-    }
-  }
-  __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3);
-  __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 593, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __pyx_v_name = __pyx_t_1;
-  __pyx_t_1 = 0;
+  size_t __pyx_t_9;
+  PyObject *__pyx_t_10 = NULL;
+  PyObject *(*__pyx_t_11)(PyObject *);
+  int __pyx_t_12;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("set_function_args", 0);
 
-  __pyx_t_5 = PyObject_Length(__pyx_n_s_in); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(1, 594, __pyx_L1_error)
-  __pyx_t_2 = __Pyx_PyObject_GetSlice(__pyx_v_name, __pyx_t_5, 0, NULL, NULL, NULL, 1, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 594, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_lower); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 594, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __pyx_t_2 = NULL;
-  if (CYTHON_UNPACK_METHODS && likely(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_1 = (__pyx_t_2) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2) : __Pyx_PyObject_CallNoArg(__pyx_t_3);
-  __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
-  if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 594, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_Function__local); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 305, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __Pyx_DECREF_SET(__pyx_v_name, __pyx_t_1);
+  __pyx_v_local = __pyx_t_1;
   __pyx_t_1 = 0;
 
-  __pyx_t_6 = (__Pyx_PySequence_ContainsTF(__pyx_n_s_real, __pyx_v_name, Py_EQ)); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 595, __pyx_L1_error)
-  __pyx_t_7 = (__pyx_t_6 != 0);
-  if (__pyx_t_7) {
+  __pyx_v_update_info = 0;
 
-    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_name, __pyx_n_s_replace); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 596, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_1);
-    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__7, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 596, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_3);
-    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-    __Pyx_DECREF_SET(__pyx_v_name, __pyx_t_3);
-    __pyx_t_3 = 0;
+  __pyx_t_2 = 0;
+  __pyx_t_5 = __Pyx_dict_iterator(__pyx_v_kwargs, 1, ((PyObject *)NULL), (&__pyx_t_3), (&__pyx_t_4)); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 308, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_1);
+  __pyx_t_1 = __pyx_t_5;
+  __pyx_t_5 = 0;
+  while (1) {
+    __pyx_t_6 = __Pyx_dict_iter_next(__pyx_t_1, __pyx_t_3, &__pyx_t_2, &__pyx_t_5, NULL, NULL, __pyx_t_4);
+    if (unlikely(__pyx_t_6 == 0)) break;
+    if (unlikely(__pyx_t_6 == -1)) __PYX_ERR(2, 308, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __Pyx_XDECREF_SET(__pyx_v_key, __pyx_t_5);
+    __pyx_t_5 = 0;
 
-    goto __pyx_L3;
-  }
+    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_opt_inputs); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 309, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __pyx_t_7 = (__Pyx_PySequence_ContainsTF(__pyx_v_key, __pyx_t_5, Py_EQ)); if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(2, 309, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    if (__pyx_t_7) {
 
-  __pyx_t_7 = (__Pyx_PySequence_ContainsTF(__pyx_n_s_price, __pyx_v_name, Py_EQ)); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(1, 597, __pyx_L1_error)
-  __pyx_t_6 = (__pyx_t_7 != 0);
-  if (__pyx_t_6) {
+      __pyx_t_5 = __Pyx_PyDict_GetItem(__pyx_v_kwargs, __pyx_v_key); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 310, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_XDECREF_SET(__pyx_v_value, __pyx_t_5);
+      __pyx_t_5 = 0;
 
-    __Pyx_INCREF(__pyx_n_s_prices);
-    __Pyx_DECREF_SET(__pyx_v_name, __pyx_n_s_prices);
+      __pyx_t_8 = __pyx_v_self;
+      __Pyx_INCREF(__pyx_t_8);
+      __pyx_t_9 = 0;
+      {
+        PyObject *__pyx_callargs[3] = {__pyx_t_8, __pyx_v_key, __pyx_v_value};
+        __pyx_t_5 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_Function__check_opt_input_value, __pyx_callargs+__pyx_t_9, (3-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+        __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+        if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 311, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_5);
+      }
+      __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(2, 311, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      if (__pyx_t_7) {
 
-  }
-  __pyx_L3:;
+        __pyx_t_5 = __Pyx_PyDict_GetItem(__pyx_v_kwargs, __pyx_v_key); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 312, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_5);
+        __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_opt_inputs); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 312, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_8);
+        __pyx_t_10 = __Pyx_PyObject_GetItem(__pyx_t_8, __pyx_v_key); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 312, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_10);
+        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+        if (unlikely((PyObject_SetItem(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_value, __pyx_t_5) < 0))) __PYX_ERR(2, 312, __pyx_L1_error)
+        __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
 
-  __Pyx_XDECREF(__pyx_r);
+        __pyx_v_update_info = 1;
 
-  __pyx_t_3 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 601, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_name, __pyx_v_name) < 0) __PYX_ERR(1, 601, __pyx_L1_error)
+      }
 
-  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_get_flags); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 602, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_4 = __Pyx_PyInt_From_TA_InputFlags(__pyx_v_info->flags); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 602, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_4);
-  __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_TA_INPUT_FLAGS); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 602, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_8);
-  __pyx_t_9 = NULL;
-  __pyx_t_10 = 0;
-  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) {
-    __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_2);
-    if (likely(__pyx_t_9)) {
-      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
-      __Pyx_INCREF(__pyx_t_9);
-      __Pyx_INCREF(function);
-      __Pyx_DECREF_SET(__pyx_t_2, function);
-      __pyx_t_10 = 1;
+      goto __pyx_L5;
     }
-  }
-  #if CYTHON_FAST_PYCALL
-  if (PyFunction_Check(__pyx_t_2)) {
-    PyObject *__pyx_temp[3] = {__pyx_t_9, __pyx_t_4, __pyx_t_8};
-    __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_10, 2+__pyx_t_10); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 602, __pyx_L1_error)
-    __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
-    __Pyx_GOTREF(__pyx_t_1);
-    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
-  } else
-  #endif
-  #if CYTHON_FAST_PYCCALL
-  if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
-    PyObject *__pyx_temp[3] = {__pyx_t_9, __pyx_t_4, __pyx_t_8};
-    __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_10, 2+__pyx_t_10); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 602, __pyx_L1_error)
-    __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
-    __Pyx_GOTREF(__pyx_t_1);
-    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
-  } else
-  #endif
+
+    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_input_names); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 314, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __pyx_t_7 = (__Pyx_PySequence_ContainsTF(__pyx_v_key, __pyx_t_5, Py_EQ)); if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(2, 314, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    if (__pyx_t_7) {
+
+      __pyx_t_5 = __Pyx_PyDict_GetItem(__pyx_v_kwargs, __pyx_v_key); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 315, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_input_names); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 315, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_10);
+      __pyx_t_8 = __Pyx_PyObject_GetItem(__pyx_t_10, __pyx_v_key); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 315, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_8);
+      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+      if (unlikely((PyObject_SetItem(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_price_series, __pyx_t_5) < 0))) __PYX_ERR(2, 315, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+      __pyx_t_5 = __Pyx_PyDict_GetItem(__pyx_v_kwargs, __pyx_v_key); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 316, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_info); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 316, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_8);
+      __pyx_t_10 = __Pyx_PyObject_Dict_GetItem(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_input_names); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 316, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_10);
+      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+      if (unlikely((PyObject_SetItem(__pyx_t_10, __pyx_v_key, __pyx_t_5) < 0))) __PYX_ERR(2, 316, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+    }
+    __pyx_L5:;
+  }
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
   {
-    __pyx_t_11 = PyTuple_New(2+__pyx_t_10); if (unlikely(!__pyx_t_11)) __PYX_ERR(1, 602, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_11);
-    if (__pyx_t_9) {
-      __Pyx_GIVEREF(__pyx_t_9); PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_9); __pyx_t_9 = NULL;
+    Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_v_args);
+    if (unlikely(((!CYTHON_ASSUME_SAFE_SIZE) && __pyx_temp < 0))) __PYX_ERR(2, 318, __pyx_L1_error)
+    __pyx_t_7 = (__pyx_temp != 0);
+  }
+
+  if (__pyx_t_7) {
+
+    __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0);
+    __pyx_v_skip_first = __pyx_mstate_global->__pyx_int_0;
+
+    __pyx_t_5 = __pyx_v_self;
+    __Pyx_INCREF(__pyx_t_5);
+    __pyx_t_10 = __Pyx_GetItemInt_Tuple(__pyx_v_args, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 320, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_10);
+    __pyx_t_9 = 0;
+    {
+      PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_10};
+      __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_set_input_arrays, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+      if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 320, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
     }
-    __Pyx_GIVEREF(__pyx_t_4);
-    PyTuple_SET_ITEM(__pyx_t_11, 0+__pyx_t_10, __pyx_t_4);
-    __Pyx_GIVEREF(__pyx_t_8);
-    PyTuple_SET_ITEM(__pyx_t_11, 1+__pyx_t_10, __pyx_t_8);
-    __pyx_t_4 = 0;
-    __pyx_t_8 = 0;
-    __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_11, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 602, __pyx_L1_error)
+    __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(2, 320, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    if (__pyx_t_7) {
+
+      __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1);
+      __Pyx_DECREF_SET(__pyx_v_skip_first, __pyx_mstate_global->__pyx_int_1);
+
+    }
+
+    __pyx_t_3 = __Pyx_PyTuple_GET_SIZE(__pyx_v_args); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(2, 322, __pyx_L1_error)
+    __pyx_t_1 = PyLong_FromSsize_t(__pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 322, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_1);
-    __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+    __pyx_t_10 = PyObject_RichCompare(__pyx_t_1, __pyx_v_skip_first, Py_GT); __Pyx_XGOTREF(__pyx_t_10); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 322, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_10); if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(2, 322, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+    if (__pyx_t_7) {
+
+      __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0);
+      __pyx_t_10 = __pyx_mstate_global->__pyx_int_0;
+      __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_opt_inputs); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 323, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      if (likely(PyList_CheckExact(__pyx_t_1)) || PyTuple_CheckExact(__pyx_t_1)) {
+        __pyx_t_5 = __pyx_t_1; __Pyx_INCREF(__pyx_t_5);
+        __pyx_t_3 = 0;
+        __pyx_t_11 = NULL;
+      } else {
+        __pyx_t_3 = -1; __pyx_t_5 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 323, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_5);
+        __pyx_t_11 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_5); if (unlikely(!__pyx_t_11)) __PYX_ERR(2, 323, __pyx_L1_error)
+      }
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+      for (;;) {
+        if (likely(!__pyx_t_11)) {
+          if (likely(PyList_CheckExact(__pyx_t_5))) {
+            {
+              Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_5);
+              #if !CYTHON_ASSUME_SAFE_SIZE
+              if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 323, __pyx_L1_error)
+              #endif
+              if (__pyx_t_3 >= __pyx_temp) break;
+            }
+            __pyx_t_1 = __Pyx_PyList_GetItemRef(__pyx_t_5, __pyx_t_3);
+            ++__pyx_t_3;
+          } else {
+            {
+              Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_5);
+              #if !CYTHON_ASSUME_SAFE_SIZE
+              if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 323, __pyx_L1_error)
+              #endif
+              if (__pyx_t_3 >= __pyx_temp) break;
+            }
+            #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+            __pyx_t_1 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_5, __pyx_t_3));
+            #else
+            __pyx_t_1 = __Pyx_PySequence_ITEM(__pyx_t_5, __pyx_t_3);
+            #endif
+            ++__pyx_t_3;
+          }
+          if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 323, __pyx_L1_error)
+        } else {
+          __pyx_t_1 = __pyx_t_11(__pyx_t_5);
+          if (unlikely(!__pyx_t_1)) {
+            PyObject* exc_type = PyErr_Occurred();
+            if (exc_type) {
+              if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(2, 323, __pyx_L1_error)
+              PyErr_Clear();
+            }
+            break;
+          }
+        }
+        __Pyx_GOTREF(__pyx_t_1);
+        __Pyx_XDECREF_SET(__pyx_v_param_name, __pyx_t_1);
+        __pyx_t_1 = 0;
+        __Pyx_INCREF(__pyx_t_10);
+        __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_10);
+        __pyx_t_1 = __Pyx_PyLong_AddObjC(__pyx_t_10, __pyx_mstate_global->__pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 323, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_1);
+        __Pyx_DECREF(__pyx_t_10);
+        __pyx_t_10 = __pyx_t_1;
+        __pyx_t_1 = 0;
+
+        __pyx_t_1 = PyNumber_InPlaceAdd(__pyx_v_i, __pyx_v_skip_first); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 324, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_1);
+        __Pyx_DECREF_SET(__pyx_v_i, __pyx_t_1);
+        __pyx_t_1 = 0;
+
+        __pyx_t_2 = __Pyx_PyTuple_GET_SIZE(__pyx_v_args); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(2, 325, __pyx_L1_error)
+        __pyx_t_1 = PyLong_FromSsize_t(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 325, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_1);
+        __pyx_t_8 = PyObject_RichCompare(__pyx_v_i, __pyx_t_1, Py_LT); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 325, __pyx_L1_error)
+        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+        __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(2, 325, __pyx_L1_error)
+        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+        if (__pyx_t_7) {
+
+          __pyx_t_8 = __Pyx_PyObject_GetItem(__pyx_v_args, __pyx_v_i); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 326, __pyx_L1_error)
+          __Pyx_GOTREF(__pyx_t_8);
+          __Pyx_XDECREF_SET(__pyx_v_value, __pyx_t_8);
+          __pyx_t_8 = 0;
+
+          __pyx_t_1 = __pyx_v_self;
+          __Pyx_INCREF(__pyx_t_1);
+          __pyx_t_9 = 0;
+          {
+            PyObject *__pyx_callargs[3] = {__pyx_t_1, __pyx_v_param_name, __pyx_v_value};
+            __pyx_t_8 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_Function__check_opt_input_value, __pyx_callargs+__pyx_t_9, (3-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+            __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+            if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 327, __pyx_L1_error)
+            __Pyx_GOTREF(__pyx_t_8);
+          }
+          __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(2, 327, __pyx_L1_error)
+          __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+          if (__pyx_t_7) {
+
+            __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_opt_inputs); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 328, __pyx_L1_error)
+            __Pyx_GOTREF(__pyx_t_8);
+            __pyx_t_1 = __Pyx_PyObject_GetItem(__pyx_t_8, __pyx_v_param_name); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 328, __pyx_L1_error)
+            __Pyx_GOTREF(__pyx_t_1);
+            __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+            if (unlikely((PyObject_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_value, __pyx_v_value) < 0))) __PYX_ERR(2, 328, __pyx_L1_error)
+            __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+            __pyx_v_update_info = 1;
+
+          }
+
+        }
+
+      }
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+
+    }
+
+  }
+
+  {
+    Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_v_args);
+    if (unlikely(((!CYTHON_ASSUME_SAFE_SIZE) && __pyx_temp < 0))) __PYX_ERR(2, 331, __pyx_L1_error)
+    __pyx_t_12 = (__pyx_temp != 0);
+  }
+
+  if (!__pyx_t_12) {
+  } else {
+    __pyx_t_7 = __pyx_t_12;
+    goto __pyx_L16_bool_binop_done;
+  }
+  __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_v_kwargs); if (unlikely((__pyx_t_12 < 0))) __PYX_ERR(2, 331, __pyx_L1_error)
+  __pyx_t_7 = __pyx_t_12;
+  __pyx_L16_bool_binop_done:;
+  if (__pyx_t_7) {
+
+    if (__pyx_v_update_info) {
+
+      __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_parameters); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 333, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_10);
+      __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_info); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 333, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      if (unlikely((PyObject_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_parameters, __pyx_t_10) < 0))) __PYX_ERR(2, 333, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+
+    }
+
+    if (__Pyx_PyObject_SetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_outputs_valid, Py_False) < (0)) __PYX_ERR(2, 334, __pyx_L1_error)
+
   }
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_price_series, __pyx_t_1) < 0) __PYX_ERR(1, 601, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_r = __pyx_t_3;
-  __pyx_t_3 = 0;
-  goto __pyx_L0;
 
 
   /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
   __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_8);
-  __Pyx_XDECREF(__pyx_t_9);
-  __Pyx_XDECREF(__pyx_t_11);
-  __Pyx_AddTraceback("talib._ta_lib._ta_getInputParameterInfo", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_XDECREF(__pyx_t_10);
+  __Pyx_AddTraceback("talib._ta_lib.Function.set_function_args", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF(__pyx_v_name);
+  __Pyx_XDECREF(__pyx_v_local);
+  __Pyx_XDECREF(__pyx_v_key);
+  __Pyx_XDECREF(__pyx_v_value);
+  __Pyx_XDECREF(__pyx_v_skip_first);
+  __Pyx_XDECREF(__pyx_v_i);
+  __Pyx_XDECREF(__pyx_v_param_name);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -37267,235 +44394,308 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_350_ta_getInputParameterInfo(CYTHON_UN
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_353_ta_getOptInputParameterInfo(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_352_ta_getOptInputParameterInfo[] = "\n    Returns the function's opt_input info dict for the given index. It has the\n    following keys: name, display_name, type, help, default_value and value.\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_353_ta_getOptInputParameterInfo = {"_ta_getOptInputParameterInfo", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_353_ta_getOptInputParameterInfo, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_352_ta_getOptInputParameterInfo};
-static PyObject *__pyx_pw_5talib_7_ta_lib_353_ta_getOptInputParameterInfo(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  char *__pyx_v_function_name;
-  int __pyx_v_idx;
+static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_25lookback(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_8Function_24lookback, "Function.lookback(self)\n\nReturns the lookback window size for the function with the parameter\nvalues that are currently set.");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_8Function_25lookback = {"lookback", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_8Function_25lookback, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_8Function_24lookback};
+static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_25lookback(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyObject *__pyx_v_self = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("_ta_getOptInputParameterInfo (wrapper)", 0);
+  __Pyx_RefNannySetupContext("lookback (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_function_name,&__pyx_n_s_idx,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);
-        CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(2, 336, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 336, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_function_name)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_idx)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("_ta_getOptInputParameterInfo", 1, 2, 2, 1); __PYX_ERR(1, 605, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "_ta_getOptInputParameterInfo") < 0)) __PYX_ERR(1, 605, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "lookback", 0) < (0)) __PYX_ERR(2, 336, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("lookback", 1, 1, 1, i); __PYX_ERR(2, 336, __pyx_L3_error) }
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
+    } else if (unlikely(__pyx_nargs != 1)) {
       goto __pyx_L5_argtuple_error;
     } else {
-      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 336, __pyx_L3_error)
     }
-    __pyx_v_function_name = __Pyx_PyObject_AsWritableString(values[0]); if (unlikely((!__pyx_v_function_name) && PyErr_Occurred())) __PYX_ERR(1, 605, __pyx_L3_error)
-    __pyx_v_idx = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_idx == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 605, __pyx_L3_error)
+    __pyx_v_self = values[0];
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("_ta_getOptInputParameterInfo", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 605, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("lookback", 1, 1, 1, __pyx_nargs); __PYX_ERR(2, 336, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib._ta_getOptInputParameterInfo", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.Function.lookback", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_352_ta_getOptInputParameterInfo(__pyx_self, __pyx_v_function_name, __pyx_v_idx);
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_8Function_24lookback(__pyx_self, __pyx_v_self);
 
   /* function exit code */
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_352_ta_getOptInputParameterInfo(CYTHON_UNUSED PyObject *__pyx_self, char *__pyx_v_function_name, int __pyx_v_idx) {
-  TA_OptInputParameterInfo *__pyx_v_info;
-  TA_RetCode __pyx_v_retCode;
-  PyObject *__pyx_v_name = NULL;
-  PyObject *__pyx_v_default_value = NULL;
+static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_24lookback(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
+  PyObject *__pyx_v_local = NULL;
+  TA_ParamHolder *__pyx_v_holder;
+  PyObject *__pyx_v_i = NULL;
+  PyObject *__pyx_v_opt_input = NULL;
+  PyObject *__pyx_v_value = NULL;
+  PyObject *__pyx_v_type_ = NULL;
+  int __pyx_v_lookback;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  PyObject *__pyx_t_2 = NULL;
-  PyObject *__pyx_t_3 = NULL;
+  char *__pyx_t_2;
+  TA_ParamHolder *__pyx_t_3;
   PyObject *__pyx_t_4 = NULL;
-  Py_ssize_t __pyx_t_5;
-  int __pyx_t_6;
-  PyObject *__pyx_t_7 = NULL;
-  __Pyx_RefNannySetupContext("_ta_getOptInputParameterInfo", 0);
+  PyObject *__pyx_t_5 = NULL;
+  Py_ssize_t __pyx_t_6;
+  PyObject *(*__pyx_t_7)(PyObject *);
+  PyObject *__pyx_t_8 = NULL;
+  size_t __pyx_t_9;
+  int __pyx_t_10;
+  int __pyx_t_11;
+  int __pyx_t_12;
+  double __pyx_t_13;
+  int __pyx_t_14;
+  int __pyx_t_15;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("lookback", 0);
 
-  __pyx_v_retCode = TA_GetOptInputParameterInfo(__pyx_f_5talib_7_ta_lib___ta_getFuncHandle(__pyx_v_function_name), __pyx_v_idx, (&__pyx_v_info));
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_Function__local); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 342, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_local = __pyx_t_1;
+  __pyx_t_1 = 0;
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_GetOptInputParameterInfo, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 612, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_Function__name); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 344, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyObject_AsWritableString(__pyx_t_1); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) __PYX_ERR(2, 344, __pyx_L1_error)
+  __pyx_t_3 = __pyx_f_5talib_7_ta_lib___ta_paramHolderAlloc(__pyx_t_2); if (unlikely(__pyx_t_3 == ((TA_ParamHolder *)0) && PyErr_Occurred())) __PYX_ERR(2, 344, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v_holder = __pyx_t_3;
 
-  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_bytes2str); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 614, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = __Pyx_PyBytes_FromString(__pyx_v_info->paramName); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 614, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __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);
-    }
+  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0);
+  __pyx_t_1 = __pyx_mstate_global->__pyx_int_0;
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_opt_inputs); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 345, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  if (likely(PyList_CheckExact(__pyx_t_4)) || PyTuple_CheckExact(__pyx_t_4)) {
+    __pyx_t_5 = __pyx_t_4; __Pyx_INCREF(__pyx_t_5);
+    __pyx_t_6 = 0;
+    __pyx_t_7 = NULL;
+  } else {
+    __pyx_t_6 = -1; __pyx_t_5 = PyObject_GetIter(__pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 345, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __pyx_t_7 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_5); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 345, __pyx_L1_error)
   }
-  __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3);
-  __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 614, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __pyx_v_name = __pyx_t_1;
-  __pyx_t_1 = 0;
-
-  __pyx_t_5 = PyObject_Length(__pyx_n_s_optIn); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(1, 615, __pyx_L1_error)
-  __pyx_t_2 = __Pyx_PyObject_GetSlice(__pyx_v_name, __pyx_t_5, 0, NULL, NULL, NULL, 1, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 615, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_lower); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 615, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __pyx_t_2 = NULL;
-  if (CYTHON_UNPACK_METHODS && likely(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_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  for (;;) {
+    if (likely(!__pyx_t_7)) {
+      if (likely(PyList_CheckExact(__pyx_t_5))) {
+        {
+          Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_5);
+          #if !CYTHON_ASSUME_SAFE_SIZE
+          if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 345, __pyx_L1_error)
+          #endif
+          if (__pyx_t_6 >= __pyx_temp) break;
+        }
+        __pyx_t_4 = __Pyx_PyList_GetItemRef(__pyx_t_5, __pyx_t_6);
+        ++__pyx_t_6;
+      } else {
+        {
+          Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_5);
+          #if !CYTHON_ASSUME_SAFE_SIZE
+          if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 345, __pyx_L1_error)
+          #endif
+          if (__pyx_t_6 >= __pyx_temp) break;
+        }
+        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+        __pyx_t_4 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_5, __pyx_t_6));
+        #else
+        __pyx_t_4 = __Pyx_PySequence_ITEM(__pyx_t_5, __pyx_t_6);
+        #endif
+        ++__pyx_t_6;
+      }
+      if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 345, __pyx_L1_error)
+    } else {
+      __pyx_t_4 = __pyx_t_7(__pyx_t_5);
+      if (unlikely(!__pyx_t_4)) {
+        PyObject* exc_type = PyErr_Occurred();
+        if (exc_type) {
+          if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(2, 345, __pyx_L1_error)
+          PyErr_Clear();
+        }
+        break;
+      }
     }
-  }
-  __pyx_t_1 = (__pyx_t_2) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2) : __Pyx_PyObject_CallNoArg(__pyx_t_3);
-  __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
-  if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 615, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __Pyx_DECREF_SET(__pyx_v_name, __pyx_t_1);
-  __pyx_t_1 = 0;
-
-  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_info->defaultValue); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 616, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_v_default_value = __pyx_t_1;
-  __pyx_t_1 = 0;
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_XDECREF_SET(__pyx_v_opt_input, __pyx_t_4);
+    __pyx_t_4 = 0;
+    __Pyx_INCREF(__pyx_t_1);
+    __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_1);
+    __pyx_t_4 = __Pyx_PyLong_AddObjC(__pyx_t_1, __pyx_mstate_global->__pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 345, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_1);
+    __pyx_t_1 = __pyx_t_4;
+    __pyx_t_4 = 0;
 
-  __pyx_t_1 = __Pyx_PyInt_RemainderObjC(__pyx_v_default_value, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 617, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_3 = __Pyx_PyInt_EqObjC(__pyx_t_1, __pyx_int_0, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 617, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 617, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  if (__pyx_t_6) {
+    __pyx_t_8 = __pyx_v_self;
+    __Pyx_INCREF(__pyx_t_8);
+    __pyx_t_9 = 0;
+    {
+      PyObject *__pyx_callargs[2] = {__pyx_t_8, __pyx_v_opt_input};
+      __pyx_t_4 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_Function__get_opt_input_value, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+      __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+      if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 346, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+    }
+    __Pyx_XDECREF_SET(__pyx_v_value, __pyx_t_4);
+    __pyx_t_4 = 0;
 
-    __pyx_t_3 = __Pyx_PyNumber_Int(__pyx_v_default_value); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 618, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_3);
-    __Pyx_DECREF_SET(__pyx_v_default_value, __pyx_t_3);
-    __pyx_t_3 = 0;
+    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_opt_inputs); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 347, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_8 = __Pyx_PyObject_GetItem(__pyx_t_4, __pyx_v_opt_input); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 347, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_8);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __pyx_t_4 = __Pyx_PyObject_Dict_GetItem(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_type_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 347, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+    __Pyx_XDECREF_SET(__pyx_v_type_, __pyx_t_4);
+    __pyx_t_4 = 0;
 
-  }
+    __pyx_t_4 = __Pyx_PyLong_From_TA_OptInputParameterType(TA_OptInput_RealRange); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 348, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_8 = PyObject_RichCompare(__pyx_v_type_, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 348, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely((__pyx_t_11 < 0))) __PYX_ERR(2, 348, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+    if (!__pyx_t_11) {
+    } else {
+      __pyx_t_10 = __pyx_t_11;
+      goto __pyx_L6_bool_binop_done;
+    }
+    __pyx_t_8 = __Pyx_PyLong_From_TA_OptInputParameterType(TA_OptInput_RealList); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 348, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_8);
+    __pyx_t_4 = PyObject_RichCompare(__pyx_v_type_, __pyx_t_8, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 348, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+    __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_11 < 0))) __PYX_ERR(2, 348, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __pyx_t_10 = __pyx_t_11;
+    __pyx_L6_bool_binop_done:;
+    if (__pyx_t_10) {
 
-  __Pyx_XDECREF(__pyx_r);
+      __pyx_t_12 = __Pyx_PyLong_As_int(__pyx_v_i); if (unlikely((__pyx_t_12 == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 349, __pyx_L1_error)
+      __pyx_t_13 = __Pyx_PyFloat_AsDouble(__pyx_v_value); if (unlikely((__pyx_t_13 == (double)-1) && PyErr_Occurred())) __PYX_ERR(2, 349, __pyx_L1_error)
+      __pyx_t_14 = __pyx_f_5talib_7_ta_lib___ta_setOptInputParamReal(__pyx_v_holder, __pyx_t_12, __pyx_t_13); if (unlikely(__pyx_t_14 == ((int)-1) && PyErr_Occurred())) __PYX_ERR(2, 349, __pyx_L1_error)
 
-  __pyx_t_3 = __Pyx_PyDict_NewPresized(6); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 621, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_name, __pyx_v_name) < 0) __PYX_ERR(1, 621, __pyx_L1_error)
+      goto __pyx_L5;
+    }
 
-  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_bytes2str); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 622, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_4 = __Pyx_PyBytes_FromString(__pyx_v_info->displayName); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 622, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_4);
-  __pyx_t_7 = NULL;
-  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) {
-    __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_2);
-    if (likely(__pyx_t_7)) {
-      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
-      __Pyx_INCREF(__pyx_t_7);
-      __Pyx_INCREF(function);
-      __Pyx_DECREF_SET(__pyx_t_2, function);
+    __pyx_t_4 = __Pyx_PyLong_From_TA_OptInputParameterType(TA_OptInput_IntegerRange); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 350, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_8 = PyObject_RichCompare(__pyx_v_type_, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 350, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely((__pyx_t_11 < 0))) __PYX_ERR(2, 350, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+    if (!__pyx_t_11) {
+    } else {
+      __pyx_t_10 = __pyx_t_11;
+      goto __pyx_L8_bool_binop_done;
     }
-  }
-  __pyx_t_1 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_7, __pyx_t_4) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_4);
-  __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
-  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 622, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_display_name, __pyx_t_1) < 0) __PYX_ERR(1, 621, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __pyx_t_8 = __Pyx_PyLong_From_TA_OptInputParameterType(TA_OptInput_IntegerList); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 350, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_8);
+    __pyx_t_4 = PyObject_RichCompare(__pyx_v_type_, __pyx_t_8, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 350, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+    __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_11 < 0))) __PYX_ERR(2, 350, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __pyx_t_10 = __pyx_t_11;
+    __pyx_L8_bool_binop_done:;
+    if (__pyx_t_10) {
 
-  __pyx_t_1 = __Pyx_PyInt_From_TA_OptInputParameterType(__pyx_v_info->type); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 623, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_type_2, __pyx_t_1) < 0) __PYX_ERR(1, 621, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+      __pyx_t_14 = __Pyx_PyLong_As_int(__pyx_v_i); if (unlikely((__pyx_t_14 == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 351, __pyx_L1_error)
+      __pyx_t_12 = __Pyx_PyLong_As_int(__pyx_v_value); if (unlikely((__pyx_t_12 == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 351, __pyx_L1_error)
+      __pyx_t_15 = __pyx_f_5talib_7_ta_lib___ta_setOptInputParamInteger(__pyx_v_holder, __pyx_t_14, __pyx_t_12); if (unlikely(__pyx_t_15 == ((int)-1) && PyErr_Occurred())) __PYX_ERR(2, 351, __pyx_L1_error)
 
-  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_bytes2str); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 624, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_4 = __Pyx_PyBytes_FromString(__pyx_v_info->hint); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 624, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_4);
-  __pyx_t_7 = NULL;
-  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) {
-    __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_2);
-    if (likely(__pyx_t_7)) {
-      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
-      __Pyx_INCREF(__pyx_t_7);
-      __Pyx_INCREF(function);
-      __Pyx_DECREF_SET(__pyx_t_2, function);
     }
+    __pyx_L5:;
+
   }
-  __pyx_t_1 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_7, __pyx_t_4) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_4);
-  __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
-  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 624, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_help, __pyx_t_1) < 0) __PYX_ERR(1, 621, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
-  if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_default_value, __pyx_v_default_value) < 0) __PYX_ERR(1, 621, __pyx_L1_error)
+  __pyx_t_15 = __pyx_f_5talib_7_ta_lib___ta_getLookback(__pyx_v_holder); if (unlikely(__pyx_t_15 == ((int)-1) && PyErr_Occurred())) __PYX_ERR(2, 353, __pyx_L1_error)
+  __pyx_v_lookback = __pyx_t_15;
 
-  if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_value, Py_None) < 0) __PYX_ERR(1, 621, __pyx_L1_error)
-  __pyx_r = __pyx_t_3;
-  __pyx_t_3 = 0;
+  __pyx_t_15 = __pyx_f_5talib_7_ta_lib___ta_paramHolderFree(__pyx_v_holder); if (unlikely(__pyx_t_15 == ((int)-1) && PyErr_Occurred())) __PYX_ERR(2, 354, __pyx_L1_error)
+
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_lookback); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 355, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
   goto __pyx_L0;
 
 
   /* 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_7);
-  __Pyx_AddTraceback("talib._ta_lib._ta_getOptInputParameterInfo", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_AddTraceback("talib._ta_lib.Function.lookback", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF(__pyx_v_name);
-  __Pyx_XDECREF(__pyx_v_default_value);
+  __Pyx_XDECREF(__pyx_v_local);
+  __Pyx_XDECREF(__pyx_v_i);
+  __Pyx_XDECREF(__pyx_v_opt_input);
+  __Pyx_XDECREF(__pyx_v_value);
+  __Pyx_XDECREF(__pyx_v_type_);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -37503,244 +44703,140 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_352_ta_getOptInputParameterInfo(CYTHON
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_355_ta_getOutputParameterInfo(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_354_ta_getOutputParameterInfo[] = "\n    Returns the function's output info dict for the given index. It has two\n    keys: name and flags.\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_355_ta_getOutputParameterInfo = {"_ta_getOutputParameterInfo", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_355_ta_getOutputParameterInfo, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_354_ta_getOutputParameterInfo};
-static PyObject *__pyx_pw_5talib_7_ta_lib_355_ta_getOutputParameterInfo(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  char *__pyx_v_function_name;
-  int __pyx_v_idx;
+static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_27output_names(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_8Function_26output_names, "Function.output_names(self)\n\nReturns a list of the output names returned by this function.");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_8Function_27output_names = {"output_names", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_8Function_27output_names, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_8Function_26output_names};
+static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_27output_names(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyObject *__pyx_v_self = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("_ta_getOutputParameterInfo (wrapper)", 0);
+  __Pyx_RefNannySetupContext("output_names (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_function_name,&__pyx_n_s_idx,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);
-        CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(2, 357, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 357, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_function_name)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_idx)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("_ta_getOutputParameterInfo", 1, 2, 2, 1); __PYX_ERR(1, 629, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "_ta_getOutputParameterInfo") < 0)) __PYX_ERR(1, 629, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "output_names", 0) < (0)) __PYX_ERR(2, 357, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("output_names", 1, 1, 1, i); __PYX_ERR(2, 357, __pyx_L3_error) }
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
+    } else if (unlikely(__pyx_nargs != 1)) {
       goto __pyx_L5_argtuple_error;
     } else {
-      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 357, __pyx_L3_error)
     }
-    __pyx_v_function_name = __Pyx_PyObject_AsWritableString(values[0]); if (unlikely((!__pyx_v_function_name) && PyErr_Occurred())) __PYX_ERR(1, 629, __pyx_L3_error)
-    __pyx_v_idx = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_idx == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 629, __pyx_L3_error)
+    __pyx_v_self = values[0];
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("_ta_getOutputParameterInfo", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 629, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("output_names", 1, 1, 1, __pyx_nargs); __PYX_ERR(2, 357, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib._ta_getOutputParameterInfo", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.Function.output_names", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_354_ta_getOutputParameterInfo(__pyx_self, __pyx_v_function_name, __pyx_v_idx);
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_8Function_26output_names(__pyx_self, __pyx_v_self);
 
   /* function exit code */
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_354_ta_getOutputParameterInfo(CYTHON_UNUSED PyObject *__pyx_self, char *__pyx_v_function_name, int __pyx_v_idx) {
-  TA_OutputParameterInfo *__pyx_v_info;
-  TA_RetCode __pyx_v_retCode;
-  PyObject *__pyx_v_name = NULL;
+static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_26output_names(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
+  PyObject *__pyx_v_ret = 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;
-  Py_ssize_t __pyx_t_5;
+  size_t __pyx_t_5;
   int __pyx_t_6;
   int __pyx_t_7;
-  int __pyx_t_8;
-  PyObject *__pyx_t_9 = NULL;
-  PyObject *__pyx_t_10 = NULL;
-  int __pyx_t_11;
-  PyObject *__pyx_t_12 = NULL;
-  __Pyx_RefNannySetupContext("_ta_getOutputParameterInfo", 0);
-
-  __pyx_v_retCode = TA_GetOutputParameterInfo(__pyx_f_5talib_7_ta_lib___ta_getFuncHandle(__pyx_v_function_name), __pyx_v_idx, (&__pyx_v_info));
-
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_GetOutputParameterInfo, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 636, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("output_names", 0);
 
-  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_bytes2str); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 638, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = __Pyx_PyBytes_FromString(__pyx_v_info->paramName); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 638, __pyx_L1_error)
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_Function__local); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 362, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
-  __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);
-    }
-  }
-  __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3);
-  __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_outputs); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 362, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 638, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __pyx_v_name = __pyx_t_1;
-  __pyx_t_1 = 0;
-
-  __pyx_t_5 = PyObject_Length(__pyx_n_s_out); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(1, 639, __pyx_L1_error)
-  __pyx_t_2 = __Pyx_PyObject_GetSlice(__pyx_v_name, __pyx_t_5, 0, NULL, NULL, NULL, 1, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 639, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_lower); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 639, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __pyx_t_2 = NULL;
-  if (CYTHON_UNPACK_METHODS && likely(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_2 = __pyx_t_4;
+  __Pyx_INCREF(__pyx_t_2);
+  __pyx_t_5 = 0;
+  {
+    PyObject *__pyx_callargs[2] = {__pyx_t_2, NULL};
+    __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_keys, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 362, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
   }
-  __pyx_t_1 = (__pyx_t_2) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2) : __Pyx_PyObject_CallNoArg(__pyx_t_3);
-  __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
-  if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 639, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __Pyx_DECREF_SET(__pyx_v_name, __pyx_t_1);
+  __pyx_v_ret = __pyx_t_1;
   __pyx_t_1 = 0;
 
-  __pyx_t_7 = (__Pyx_PySequence_ContainsTF(__pyx_n_s_real, __pyx_v_name, Py_EQ)); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(1, 641, __pyx_L1_error)
-  __pyx_t_8 = (__pyx_t_7 != 0);
-  if (__pyx_t_8) {
-  } else {
-    __pyx_t_6 = __pyx_t_8;
-    goto __pyx_L4_bool_binop_done;
-  }
-  __Pyx_INCREF(__pyx_v_name);
-  __pyx_t_1 = __pyx_v_name;
-  __pyx_t_7 = (__Pyx_PyString_Equals(__pyx_t_1, __pyx_n_s_real, Py_NE)); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(1, 641, __pyx_L1_error)
-  if (__pyx_t_7) {
-  } else {
-    __pyx_t_8 = __pyx_t_7;
-    goto __pyx_L6_bool_binop_done;
-  }
-  __pyx_t_7 = (__Pyx_PyString_Equals(__pyx_t_1, __pyx_n_s_real0, Py_NE)); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(1, 641, __pyx_L1_error)
+  __pyx_t_6 = PyList_Check(__pyx_v_ret); 
+  __pyx_t_7 = (!__pyx_t_6);
   if (__pyx_t_7) {
-  } else {
-    __pyx_t_8 = __pyx_t_7;
-    goto __pyx_L6_bool_binop_done;
-  }
-  __pyx_t_7 = (__Pyx_PyString_Equals(__pyx_t_1, __pyx_n_s_real1, Py_NE)); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(1, 641, __pyx_L1_error)
-  __pyx_t_8 = __pyx_t_7;
-  __pyx_L6_bool_binop_done:;
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_7 = (__pyx_t_8 != 0);
-  __pyx_t_6 = __pyx_t_7;
-  __pyx_L4_bool_binop_done:;
-  if (__pyx_t_6) {
 
-    __pyx_t_5 = PyObject_Length(__pyx_n_s_real); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(1, 642, __pyx_L1_error)
-    __pyx_t_1 = __Pyx_PyObject_GetSlice(__pyx_v_name, __pyx_t_5, 0, NULL, NULL, NULL, 1, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 642, __pyx_L1_error)
+    __pyx_t_1 = PySequence_List(__pyx_v_ret); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 364, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_1);
-    __Pyx_DECREF_SET(__pyx_v_name, __pyx_t_1);
+    __Pyx_DECREF_SET(__pyx_v_ret, __pyx_t_1);
     __pyx_t_1 = 0;
 
   }
 
   __Pyx_XDECREF(__pyx_r);
-
-  __pyx_t_1 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 645, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_name, __pyx_v_name) < 0) __PYX_ERR(1, 645, __pyx_L1_error)
-
-  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_get_flags); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 646, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_4 = __Pyx_PyInt_From_TA_OutputFlags(__pyx_v_info->flags); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 646, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_4);
-  __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_TA_OUTPUT_FLAGS); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 646, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_9);
-  __pyx_t_10 = NULL;
-  __pyx_t_11 = 0;
-  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) {
-    __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_2);
-    if (likely(__pyx_t_10)) {
-      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
-      __Pyx_INCREF(__pyx_t_10);
-      __Pyx_INCREF(function);
-      __Pyx_DECREF_SET(__pyx_t_2, function);
-      __pyx_t_11 = 1;
-    }
-  }
-  #if CYTHON_FAST_PYCALL
-  if (PyFunction_Check(__pyx_t_2)) {
-    PyObject *__pyx_temp[3] = {__pyx_t_10, __pyx_t_4, __pyx_t_9};
-    __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_11, 2+__pyx_t_11); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 646, __pyx_L1_error)
-    __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
-    __Pyx_GOTREF(__pyx_t_3);
-    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
-  } else
-  #endif
-  #if CYTHON_FAST_PYCCALL
-  if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
-    PyObject *__pyx_temp[3] = {__pyx_t_10, __pyx_t_4, __pyx_t_9};
-    __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_11, 2+__pyx_t_11); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 646, __pyx_L1_error)
-    __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
-    __Pyx_GOTREF(__pyx_t_3);
-    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
-  } else
-  #endif
-  {
-    __pyx_t_12 = PyTuple_New(2+__pyx_t_11); if (unlikely(!__pyx_t_12)) __PYX_ERR(1, 646, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_12);
-    if (__pyx_t_10) {
-      __Pyx_GIVEREF(__pyx_t_10); PyTuple_SET_ITEM(__pyx_t_12, 0, __pyx_t_10); __pyx_t_10 = NULL;
-    }
-    __Pyx_GIVEREF(__pyx_t_4);
-    PyTuple_SET_ITEM(__pyx_t_12, 0+__pyx_t_11, __pyx_t_4);
-    __Pyx_GIVEREF(__pyx_t_9);
-    PyTuple_SET_ITEM(__pyx_t_12, 1+__pyx_t_11, __pyx_t_9);
-    __pyx_t_4 = 0;
-    __pyx_t_9 = 0;
-    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_12, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 646, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_3);
-    __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
-  }
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_flags, __pyx_t_3) < 0) __PYX_ERR(1, 645, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __pyx_r = __pyx_t_1;
-  __pyx_t_1 = 0;
+  __Pyx_INCREF(__pyx_v_ret);
+  __pyx_r = __pyx_v_ret;
   goto __pyx_L0;
 
 
@@ -37750,13 +44846,10 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_354_ta_getOutputParameterInfo(CYTHON_U
   __Pyx_XDECREF(__pyx_t_2);
   __Pyx_XDECREF(__pyx_t_3);
   __Pyx_XDECREF(__pyx_t_4);
-  __Pyx_XDECREF(__pyx_t_9);
-  __Pyx_XDECREF(__pyx_t_10);
-  __Pyx_XDECREF(__pyx_t_12);
-  __Pyx_AddTraceback("talib._ta_lib._ta_getOutputParameterInfo", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.Function.output_names", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF(__pyx_v_name);
+  __Pyx_XDECREF(__pyx_v_ret);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -37764,948 +44857,1582 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_354_ta_getOutputParameterInfo(CYTHON_U
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_357_get_defaults_and_docs(PyObject *__pyx_self, PyObject *__pyx_v_func_info); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_356_get_defaults_and_docs[] = "\n    Returns a tuple with two outputs: defaults, a dict of parameter defaults,\n    and documentation, a formatted docstring for the function.\n    .. Note: func_info should come from Function.info, *not* _ta_getFuncInfo.\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_357_get_defaults_and_docs = {"_get_defaults_and_docs", (PyCFunction)__pyx_pw_5talib_7_ta_lib_357_get_defaults_and_docs, METH_O, __pyx_doc_5talib_7_ta_lib_356_get_defaults_and_docs};
-static PyObject *__pyx_pw_5talib_7_ta_lib_357_get_defaults_and_docs(PyObject *__pyx_self, PyObject *__pyx_v_func_info) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_29outputs(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_8Function_28outputs, "Function.outputs(self)\n\nReturns the TA function values for the currently set input_arrays and\nparameters. Returned values are a ndarray if there is only one output\nor a list of ndarrays for more than one output.");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_8Function_29outputs = {"outputs", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_8Function_29outputs, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_8Function_28outputs};
+static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_29outputs(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyObject *__pyx_v_self = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("_get_defaults_and_docs (wrapper)", 0);
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_356_get_defaults_and_docs(__pyx_self, ((PyObject *)__pyx_v_func_info));
+  __Pyx_RefNannySetupContext("outputs (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(2, 367, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 367, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "outputs", 0) < (0)) __PYX_ERR(2, 367, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("outputs", 1, 1, 1, i); __PYX_ERR(2, 367, __pyx_L3_error) }
+      }
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 367, __pyx_L3_error)
+    }
+    __pyx_v_self = values[0];
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("outputs", 1, 1, 1, __pyx_nargs); __PYX_ERR(2, 367, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.Function.outputs", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_8Function_28outputs(__pyx_self, __pyx_v_self);
 
   /* function exit code */
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_356_get_defaults_and_docs(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_func_info) {
-  PyObject *__pyx_v_defaults = NULL;
-  PyObject *__pyx_v_func_line = NULL;
-  PyObject *__pyx_v_func_args = NULL;
-  PyObject *__pyx_v_docs = NULL;
-  PyObject *__pyx_v_input_names = NULL;
-  PyObject *__pyx_v_input_name = NULL;
-  PyObject *__pyx_v_value = NULL;
-  PyObject *__pyx_v_params = NULL;
-  PyObject *__pyx_v_param = NULL;
-  PyObject *__pyx_v_outputs = NULL;
-  PyObject *__pyx_v_output = NULL;
-  PyObject *__pyx_v_documentation = NULL;
+static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_28outputs(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
+  PyObject *__pyx_v_local = NULL;
+  PyObject *__pyx_v_ret = NULL;
+  PyObject *__pyx_v_index = NULL;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  PyObject *__pyx_t_2 = NULL;
+  int __pyx_t_2;
   int __pyx_t_3;
-  Py_ssize_t __pyx_t_4;
-  PyObject *(*__pyx_t_5)(PyObject *);
-  int __pyx_t_6;
-  int __pyx_t_7;
+  PyObject *__pyx_t_4 = NULL;
+  size_t __pyx_t_5;
+  PyObject *__pyx_t_6 = NULL;
+  Py_ssize_t __pyx_t_7;
   PyObject *__pyx_t_8 = NULL;
   PyObject *__pyx_t_9 = NULL;
   PyObject *__pyx_t_10 = NULL;
-  __Pyx_RefNannySetupContext("_get_defaults_and_docs", 0);
+  PyObject *__pyx_t_11 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("outputs", 0);
 
-  __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 655, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_Function__local); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 374, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_v_defaults = ((PyObject*)__pyx_t_1);
+  __pyx_v_local = __pyx_t_1;
   __pyx_t_1 = 0;
 
-  __pyx_t_1 = __Pyx_PyObject_Dict_GetItem(__pyx_v_func_info, __pyx_n_s_name); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 656, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_outputs_valid); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 375, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = PyList_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 656, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_GIVEREF(__pyx_t_1);
-  PyList_SET_ITEM(__pyx_t_2, 0, __pyx_t_1);
-  __Pyx_INCREF(__pyx_kp_s__8);
-  __Pyx_GIVEREF(__pyx_kp_s__8);
-  PyList_SET_ITEM(__pyx_t_2, 1, __pyx_kp_s__8);
-  __pyx_t_1 = 0;
-  __pyx_v_func_line = ((PyObject*)__pyx_t_2);
-  __pyx_t_2 = 0;
-
-  __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 657, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_INCREF(__pyx_kp_s_input_arrays_2);
-  __Pyx_GIVEREF(__pyx_kp_s_input_arrays_2);
-  PyList_SET_ITEM(__pyx_t_2, 0, __pyx_kp_s_input_arrays_2);
-  __pyx_v_func_args = ((PyObject*)__pyx_t_2);
-  __pyx_t_2 = 0;
-
-  __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 658, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_v_docs = ((PyObject*)__pyx_t_2);
-  __pyx_t_2 = 0;
-
-  __pyx_t_2 = __Pyx_PyString_FormatSafe(__pyx_kp_s_display_name_s_group_s, __pyx_v_func_info); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 659, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = __Pyx_PyList_Append(__pyx_v_docs, __pyx_t_2); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 659, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-
-  __pyx_t_2 = __Pyx_PyObject_Dict_GetItem(__pyx_v_func_info, __pyx_n_s_input_names); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 661, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_v_input_names = __pyx_t_2;
-  __pyx_t_2 = 0;
-
-  __pyx_t_3 = __Pyx_PyList_Append(__pyx_v_docs, __pyx_kp_s_Inputs); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 662, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(2, 375, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_3 = (!__pyx_t_2);
+  if (__pyx_t_3) {
 
-  if (likely(PyList_CheckExact(__pyx_v_input_names)) || PyTuple_CheckExact(__pyx_v_input_names)) {
-    __pyx_t_2 = __pyx_v_input_names; __Pyx_INCREF(__pyx_t_2); __pyx_t_4 = 0;
-    __pyx_t_5 = NULL;
-  } else {
-    __pyx_t_4 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_v_input_names); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 663, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_2);
-    __pyx_t_5 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 663, __pyx_L1_error)
-  }
-  for (;;) {
-    if (likely(!__pyx_t_5)) {
-      if (likely(PyList_CheckExact(__pyx_t_2))) {
-        if (__pyx_t_4 >= PyList_GET_SIZE(__pyx_t_2)) break;
-        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-        __pyx_t_1 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_4); __Pyx_INCREF(__pyx_t_1); __pyx_t_4++; if (unlikely(0 < 0)) __PYX_ERR(1, 663, __pyx_L1_error)
-        #else
-        __pyx_t_1 = PySequence_ITEM(__pyx_t_2, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 663, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_1);
-        #endif
-      } else {
-        if (__pyx_t_4 >= PyTuple_GET_SIZE(__pyx_t_2)) break;
-        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-        __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_4); __Pyx_INCREF(__pyx_t_1); __pyx_t_4++; if (unlikely(0 < 0)) __PYX_ERR(1, 663, __pyx_L1_error)
-        #else
-        __pyx_t_1 = PySequence_ITEM(__pyx_t_2, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 663, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_1);
-        #endif
-      }
-    } else {
-      __pyx_t_1 = __pyx_t_5(__pyx_t_2);
-      if (unlikely(!__pyx_t_1)) {
-        PyObject* exc_type = PyErr_Occurred();
-        if (exc_type) {
-          if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
-          else __PYX_ERR(1, 663, __pyx_L1_error)
-        }
-        break;
-      }
+    __pyx_t_4 = __pyx_v_self;
+    __Pyx_INCREF(__pyx_t_4);
+    __pyx_t_5 = 0;
+    {
+      PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL};
+      __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_Function__call_function, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 376, __pyx_L1_error)
       __Pyx_GOTREF(__pyx_t_1);
     }
-    __Pyx_XDECREF_SET(__pyx_v_input_name, __pyx_t_1);
-    __pyx_t_1 = 0;
-
-    __pyx_t_1 = __Pyx_PyObject_GetItem(__pyx_v_input_names, __pyx_v_input_name); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 664, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_1);
-    __Pyx_XDECREF_SET(__pyx_v_value, __pyx_t_1);
-    __pyx_t_1 = 0;
-
-    __pyx_t_6 = PyList_Check(__pyx_v_value); 
-    __pyx_t_7 = ((!(__pyx_t_6 != 0)) != 0);
-    if (__pyx_t_7) {
-
-      __Pyx_INCREF(__pyx_kp_s_any_ndarray);
-      __Pyx_DECREF_SET(__pyx_v_value, __pyx_kp_s_any_ndarray);
-
-    }
-
-    __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 667, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_1);
-    __Pyx_INCREF(__pyx_v_input_name);
-    __Pyx_GIVEREF(__pyx_v_input_name);
-    PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_input_name);
-    __Pyx_INCREF(__pyx_v_value);
-    __Pyx_GIVEREF(__pyx_v_value);
-    PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_value);
-    __pyx_t_8 = __Pyx_PyString_Format(__pyx_kp_s_s_s, __pyx_t_1); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 667, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_8);
     __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-    __pyx_t_3 = __Pyx_PyList_Append(__pyx_v_docs, __pyx_t_8); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 667, __pyx_L1_error)
-    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
 
   }
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = __Pyx_PyObject_Dict_GetItem(__pyx_v_func_info, __pyx_n_s_parameters); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 669, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_v_params = __pyx_t_2;
-  __pyx_t_2 = 0;
+  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_outputs); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 377, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __pyx_t_4 = __pyx_t_6;
+  __Pyx_INCREF(__pyx_t_4);
+  __pyx_t_5 = 0;
+  {
+    PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL};
+    __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_values, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 377, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+  }
+  __pyx_v_ret = __pyx_t_1;
+  __pyx_t_1 = 0;
 
-  __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_v_params); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(1, 670, __pyx_L1_error)
-  if (__pyx_t_7) {
+  __pyx_t_3 = PyList_Check(__pyx_v_ret); 
+  __pyx_t_2 = (!__pyx_t_3);
+  if (__pyx_t_2) {
 
-    __pyx_t_3 = __Pyx_PyList_Append(__pyx_v_docs, __pyx_kp_s_Parameters); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 671, __pyx_L1_error)
+    __pyx_t_1 = PySequence_List(__pyx_v_ret); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 379, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF_SET(__pyx_v_ret, __pyx_t_1);
+    __pyx_t_1 = 0;
 
   }
 
-  if (likely(PyList_CheckExact(__pyx_v_params)) || PyTuple_CheckExact(__pyx_v_params)) {
-    __pyx_t_2 = __pyx_v_params; __Pyx_INCREF(__pyx_t_2); __pyx_t_4 = 0;
-    __pyx_t_5 = NULL;
+  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_PANDAS_DATAFRAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 380, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_3 = (__pyx_t_1 != Py_None);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  if (__pyx_t_3) {
   } else {
-    __pyx_t_4 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_v_params); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 672, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_2);
-    __pyx_t_5 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 672, __pyx_L1_error)
+    __pyx_t_2 = __pyx_t_3;
+    goto __pyx_L6_bool_binop_done;
   }
-  for (;;) {
-    if (likely(!__pyx_t_5)) {
-      if (likely(PyList_CheckExact(__pyx_t_2))) {
-        if (__pyx_t_4 >= PyList_GET_SIZE(__pyx_t_2)) break;
-        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-        __pyx_t_8 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_4); __Pyx_INCREF(__pyx_t_8); __pyx_t_4++; if (unlikely(0 < 0)) __PYX_ERR(1, 672, __pyx_L1_error)
-        #else
-        __pyx_t_8 = PySequence_ITEM(__pyx_t_2, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 672, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_8);
-        #endif
-      } else {
-        if (__pyx_t_4 >= PyTuple_GET_SIZE(__pyx_t_2)) break;
-        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-        __pyx_t_8 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_4); __Pyx_INCREF(__pyx_t_8); __pyx_t_4++; if (unlikely(0 < 0)) __PYX_ERR(1, 672, __pyx_L1_error)
-        #else
-        __pyx_t_8 = PySequence_ITEM(__pyx_t_2, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 672, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_8);
-        #endif
-      }
-    } else {
-      __pyx_t_8 = __pyx_t_5(__pyx_t_2);
-      if (unlikely(!__pyx_t_8)) {
-        PyObject* exc_type = PyErr_Occurred();
-        if (exc_type) {
-          if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
-          else __PYX_ERR(1, 672, __pyx_L1_error)
-        }
-        break;
-      }
-      __Pyx_GOTREF(__pyx_t_8);
-    }
-    __Pyx_XDECREF_SET(__pyx_v_param, __pyx_t_8);
-    __pyx_t_8 = 0;
 
-    __pyx_t_8 = __Pyx_PyObject_GetItem(__pyx_v_params, __pyx_v_param); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 673, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_8);
-    __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 673, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_1);
-    __Pyx_INCREF(__pyx_v_param);
-    __Pyx_GIVEREF(__pyx_v_param);
-    PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_param);
-    __Pyx_GIVEREF(__pyx_t_8);
-    PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_8);
-    __pyx_t_8 = 0;
-    __pyx_t_8 = __Pyx_PyString_Format(__pyx_kp_s_s_s, __pyx_t_1); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 673, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_8);
-    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-    __pyx_t_3 = __Pyx_PyList_Append(__pyx_v_docs, __pyx_t_8); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 673, __pyx_L1_error)
-    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_input_arrays); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 381, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_PANDAS_DATAFRAME); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 381, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __pyx_t_3 = PyObject_IsInstance(__pyx_t_1, __pyx_t_6); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(2, 381, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  __pyx_t_2 = __pyx_t_3;
+  __pyx_L6_bool_binop_done:;
 
-    __pyx_t_8 = __Pyx_PyObject_GetItem(__pyx_v_params, __pyx_v_param); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 674, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_8);
-    __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 674, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_1);
-    __Pyx_INCREF(__pyx_v_param);
-    __Pyx_GIVEREF(__pyx_v_param);
-    PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_param);
-    __Pyx_GIVEREF(__pyx_t_8);
-    PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_8);
-    __pyx_t_8 = 0;
-    __pyx_t_8 = __Pyx_PyString_Format(__pyx_kp_s_s_s_2, __pyx_t_1); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 674, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_8);
-    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-    __pyx_t_3 = __Pyx_PyList_Append(__pyx_v_func_args, __pyx_t_8); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 674, __pyx_L1_error)
-    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+  if (__pyx_t_2) {
 
-    __pyx_t_8 = __Pyx_PyObject_GetItem(__pyx_v_params, __pyx_v_param); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 675, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_8);
-    if (unlikely(PyDict_SetItem(__pyx_v_defaults, __pyx_v_param, __pyx_t_8) < 0)) __PYX_ERR(1, 675, __pyx_L1_error)
-    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+    __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_input_arrays); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 382, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_index); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 382, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __pyx_v_index = __pyx_t_1;
+    __pyx_t_1 = 0;
 
-    __pyx_t_7 = (__Pyx_PyString_Equals(__pyx_v_param, __pyx_n_s_matype, Py_EQ)); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(1, 676, __pyx_L1_error)
-    if (__pyx_t_7) {
+    __pyx_t_7 = PyObject_Length(__pyx_v_ret); if (unlikely(__pyx_t_7 == ((Py_ssize_t)-1))) __PYX_ERR(2, 383, __pyx_L1_error)
+    __pyx_t_2 = (__pyx_t_7 == 1);
+    if (__pyx_t_2) {
 
-      __pyx_t_8 = __Pyx_GetItemInt_List(__pyx_v_docs, -1L, long, 1, __Pyx_PyInt_From_long, 1, 1, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 677, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_r);
+      __pyx_t_6 = NULL;
+      __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_PANDAS_SERIES); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 384, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __pyx_t_8 = __Pyx_GetItemInt(__pyx_v_ret, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 384, __pyx_L1_error)
       __Pyx_GOTREF(__pyx_t_8);
-      __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_MA_Type); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 677, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_1);
-      __pyx_t_9 = __Pyx_PyObject_GetItem(__pyx_v_params, __pyx_v_param); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 677, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_9);
-      __pyx_t_10 = __Pyx_PyObject_GetItem(__pyx_t_1, __pyx_t_9); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 677, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_10);
-      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
-      __pyx_t_9 = __Pyx_PyString_FormatSafe(__pyx_kp_s_s_3, __pyx_t_10); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 677, __pyx_L1_error)
+      __pyx_t_5 = 1;
+      #if CYTHON_UNPACK_METHODS
+      if (unlikely(PyMethod_Check(__pyx_t_4))) {
+        __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4);
+        assert(__pyx_t_6);
+        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
+        __Pyx_INCREF(__pyx_t_6);
+        __Pyx_INCREF(__pyx__function);
+        __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
+        __pyx_t_5 = 0;
+      }
+      #endif
+      {
+        PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_6, __pyx_t_8};
+        __pyx_t_9 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 384, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_9);
+        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_index, __pyx_v_index, __pyx_t_9, __pyx_callargs+2, 0) < (0)) __PYX_ERR(2, 384, __pyx_L1_error)
+        __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder(__pyx_t_4, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_9);
+        __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+        if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 384, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_1);
+      }
+      __pyx_r = __pyx_t_1;
+      __pyx_t_1 = 0;
+      goto __pyx_L0;
+
+    }
+
+    /*else*/ {
+      __Pyx_XDECREF(__pyx_r);
+      __pyx_t_4 = NULL;
+      __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_PANDAS_DATAFRAME); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 386, __pyx_L1_error)
       __Pyx_GOTREF(__pyx_t_9);
-      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
-      __pyx_t_10 = PyList_New(2); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 677, __pyx_L1_error)
+      __pyx_t_6 = NULL;
+      __Pyx_GetModuleGlobalName(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_numpy); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 386, __pyx_L1_error)
       __Pyx_GOTREF(__pyx_t_10);
-      __Pyx_GIVEREF(__pyx_t_8);
-      PyList_SET_ITEM(__pyx_t_10, 0, __pyx_t_8);
-      __Pyx_GIVEREF(__pyx_t_9);
-      PyList_SET_ITEM(__pyx_t_10, 1, __pyx_t_9);
-      __pyx_t_8 = 0;
-      __pyx_t_9 = 0;
-      __pyx_t_9 = __Pyx_PyString_Join(__pyx_kp_s__9, __pyx_t_10); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 677, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_9);
+      __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_column_stack); if (unlikely(!__pyx_t_11)) __PYX_ERR(2, 386, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_11);
       __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
-      if (unlikely(__Pyx_SetItemInt(__pyx_v_docs, -1L, __pyx_t_9, long, 1, __Pyx_PyInt_From_long, 1, 1, 1) < 0)) __PYX_ERR(1, 677, __pyx_L1_error)
-      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+      __pyx_t_5 = 1;
+      #if CYTHON_UNPACK_METHODS
+      if (unlikely(PyMethod_Check(__pyx_t_11))) {
+        __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_11);
+        assert(__pyx_t_6);
+        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_11);
+        __Pyx_INCREF(__pyx_t_6);
+        __Pyx_INCREF(__pyx__function);
+        __Pyx_DECREF_SET(__pyx_t_11, __pyx__function);
+        __pyx_t_5 = 0;
+      }
+      #endif
+      {
+        PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_v_ret};
+        __pyx_t_8 = __Pyx_PyObject_FastCall(__pyx_t_11, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+        __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+        __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+        if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 386, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_8);
+      }
 
+      __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_output_names); if (unlikely(!__pyx_t_11)) __PYX_ERR(2, 388, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_11);
+      __pyx_t_5 = 1;
+      #if CYTHON_UNPACK_METHODS
+      if (unlikely(PyMethod_Check(__pyx_t_9))) {
+        __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_9);
+        assert(__pyx_t_4);
+        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_9);
+        __Pyx_INCREF(__pyx_t_4);
+        __Pyx_INCREF(__pyx__function);
+        __Pyx_DECREF_SET(__pyx_t_9, __pyx__function);
+        __pyx_t_5 = 0;
+      }
+      #endif
+      {
+        PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 2 : 0)] = {__pyx_t_4, __pyx_t_8};
+        __pyx_t_6 = __Pyx_MakeVectorcallBuilderKwds(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 386, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_6);
+        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_index, __pyx_v_index, __pyx_t_6, __pyx_callargs+2, 0) < (0)) __PYX_ERR(2, 386, __pyx_L1_error)
+        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_columns, __pyx_t_11, __pyx_t_6, __pyx_callargs+2, 1) < (0)) __PYX_ERR(2, 386, __pyx_L1_error)
+        __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder(__pyx_t_9, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_6);
+        __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+        __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+        if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 386, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_1);
+      }
+      __pyx_r = __pyx_t_1;
+      __pyx_t_1 = 0;
+      goto __pyx_L0;
     }
 
   }
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-
-  __pyx_t_2 = __Pyx_PyObject_Dict_GetItem(__pyx_v_func_info, __pyx_n_s_output_names); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 679, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_v_outputs = __pyx_t_2;
-  __pyx_t_2 = 0;
-
-  __pyx_t_3 = __Pyx_PyList_Append(__pyx_v_docs, __pyx_kp_s_Outputs); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 680, __pyx_L1_error)
 
-  if (likely(PyList_CheckExact(__pyx_v_outputs)) || PyTuple_CheckExact(__pyx_v_outputs)) {
-    __pyx_t_2 = __pyx_v_outputs; __Pyx_INCREF(__pyx_t_2); __pyx_t_4 = 0;
-    __pyx_t_5 = NULL;
+  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_POLARS_DATAFRAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 389, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_3 = (__pyx_t_1 != Py_None);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  if (__pyx_t_3) {
   } else {
-    __pyx_t_4 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_v_outputs); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 681, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_2);
-    __pyx_t_5 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 681, __pyx_L1_error)
+    __pyx_t_2 = __pyx_t_3;
+    goto __pyx_L9_bool_binop_done;
   }
-  for (;;) {
-    if (likely(!__pyx_t_5)) {
-      if (likely(PyList_CheckExact(__pyx_t_2))) {
-        if (__pyx_t_4 >= PyList_GET_SIZE(__pyx_t_2)) break;
-        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-        __pyx_t_9 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_4); __Pyx_INCREF(__pyx_t_9); __pyx_t_4++; if (unlikely(0 < 0)) __PYX_ERR(1, 681, __pyx_L1_error)
-        #else
-        __pyx_t_9 = PySequence_ITEM(__pyx_t_2, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 681, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_9);
-        #endif
-      } else {
-        if (__pyx_t_4 >= PyTuple_GET_SIZE(__pyx_t_2)) break;
-        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-        __pyx_t_9 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_4); __Pyx_INCREF(__pyx_t_9); __pyx_t_4++; if (unlikely(0 < 0)) __PYX_ERR(1, 681, __pyx_L1_error)
-        #else
-        __pyx_t_9 = PySequence_ITEM(__pyx_t_2, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 681, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_9);
-        #endif
-      }
-    } else {
-      __pyx_t_9 = __pyx_t_5(__pyx_t_2);
-      if (unlikely(!__pyx_t_9)) {
-        PyObject* exc_type = PyErr_Occurred();
-        if (exc_type) {
-          if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
-          else __PYX_ERR(1, 681, __pyx_L1_error)
-        }
-        break;
-      }
-      __Pyx_GOTREF(__pyx_t_9);
-    }
-    __Pyx_XDECREF_SET(__pyx_v_output, __pyx_t_9);
-    __pyx_t_9 = 0;
-
-    __pyx_t_7 = (__Pyx_PyString_Equals(__pyx_v_output, __pyx_n_s_integer, Py_EQ)); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(1, 682, __pyx_L1_error)
-    if (__pyx_t_7) {
 
-      __Pyx_INCREF(__pyx_kp_s_integer_values_are_100_0_or_100);
-      __Pyx_DECREF_SET(__pyx_v_output, __pyx_kp_s_integer_values_are_100_0_or_100);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_input_arrays); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 390, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_POLARS_DATAFRAME); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 390, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_9);
+  __pyx_t_3 = PyObject_IsInstance(__pyx_t_1, __pyx_t_9); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(2, 390, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+  __pyx_t_2 = __pyx_t_3;
+  __pyx_L9_bool_binop_done:;
 
-    }
+  if (__pyx_t_2) {
 
-    __pyx_t_9 = __Pyx_PyString_FormatSafe(__pyx_kp_s_s_4, __pyx_v_output); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 684, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_9);
-    __pyx_t_3 = __Pyx_PyList_Append(__pyx_v_docs, __pyx_t_9); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 684, __pyx_L1_error)
-    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+    __pyx_t_7 = PyObject_Length(__pyx_v_ret); if (unlikely(__pyx_t_7 == ((Py_ssize_t)-1))) __PYX_ERR(2, 391, __pyx_L1_error)
+    __pyx_t_2 = (__pyx_t_7 == 1);
+    if (__pyx_t_2) {
 
-  }
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __Pyx_XDECREF(__pyx_r);
+      __pyx_t_1 = NULL;
+      __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_POLARS_SERIES); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 392, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      __pyx_t_11 = __Pyx_GetItemInt(__pyx_v_ret, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1); if (unlikely(!__pyx_t_11)) __PYX_ERR(2, 392, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_11);
+      __pyx_t_5 = 1;
+      #if CYTHON_UNPACK_METHODS
+      if (unlikely(PyMethod_Check(__pyx_t_6))) {
+        __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_6);
+        assert(__pyx_t_1);
+        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6);
+        __Pyx_INCREF(__pyx_t_1);
+        __Pyx_INCREF(__pyx__function);
+        __Pyx_DECREF_SET(__pyx_t_6, __pyx__function);
+        __pyx_t_5 = 0;
+      }
+      #endif
+      {
+        PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_t_11};
+        __pyx_t_9 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+        __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+        __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+        if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 392, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_9);
+      }
+      __pyx_r = __pyx_t_9;
+      __pyx_t_9 = 0;
+      goto __pyx_L0;
 
-  __pyx_t_2 = __Pyx_PyString_Join(__pyx_kp_s__6, __pyx_v_func_args); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 686, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = __Pyx_PyList_Append(__pyx_v_func_line, __pyx_t_2); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 686, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    }
 
-  __pyx_t_3 = __Pyx_PyList_Append(__pyx_v_func_line, __pyx_kp_s__10); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 687, __pyx_L1_error)
+    /*else*/ {
+      __Pyx_XDECREF(__pyx_r);
+      __pyx_t_6 = NULL;
+      __Pyx_GetModuleGlobalName(__pyx_t_11, __pyx_mstate_global->__pyx_n_u_POLARS_DATAFRAME); if (unlikely(!__pyx_t_11)) __PYX_ERR(2, 394, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_11);
+      __pyx_t_8 = NULL;
+      __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_numpy); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 394, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_column_stack); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 394, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_10);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __pyx_t_5 = 1;
+      #if CYTHON_UNPACK_METHODS
+      if (unlikely(PyMethod_Check(__pyx_t_10))) {
+        __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_10);
+        assert(__pyx_t_8);
+        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_10);
+        __Pyx_INCREF(__pyx_t_8);
+        __Pyx_INCREF(__pyx__function);
+        __Pyx_DECREF_SET(__pyx_t_10, __pyx__function);
+        __pyx_t_5 = 0;
+      }
+      #endif
+      {
+        PyObject *__pyx_callargs[2] = {__pyx_t_8, __pyx_v_ret};
+        __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_10, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+        __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+        __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+        if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 394, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_1);
+      }
 
-  __pyx_t_2 = __Pyx_PyString_Join(__pyx_kp_s__5, __pyx_v_func_line); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 688, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = PyList_Insert(__pyx_v_docs, 0, __pyx_t_2); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 688, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_output_names); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 395, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_10);
+      __pyx_t_5 = 1;
+      #if CYTHON_UNPACK_METHODS
+      if (unlikely(PyMethod_Check(__pyx_t_11))) {
+        __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_11);
+        assert(__pyx_t_6);
+        PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_11);
+        __Pyx_INCREF(__pyx_t_6);
+        __Pyx_INCREF(__pyx__function);
+        __Pyx_DECREF_SET(__pyx_t_11, __pyx__function);
+        __pyx_t_5 = 0;
+      }
+      #endif
+      {
+        PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_6, __pyx_t_1};
+        __pyx_t_8 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 394, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_8);
+        if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_schema, __pyx_t_10, __pyx_t_8, __pyx_callargs+2, 0) < (0)) __PYX_ERR(2, 394, __pyx_L1_error)
+        __pyx_t_9 = __Pyx_Object_Vectorcall_CallFromBuilder(__pyx_t_11, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_8);
+        __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+        __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+        __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+        if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 394, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_9);
+      }
+      __pyx_r = __pyx_t_9;
+      __pyx_t_9 = 0;
+      goto __pyx_L0;
+    }
 
-  __pyx_t_2 = __Pyx_PyString_Join(__pyx_kp_s__11, __pyx_v_docs); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 689, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_v_documentation = ((PyObject*)__pyx_t_2);
-  __pyx_t_2 = 0;
+  }
 
-  __Pyx_XDECREF(__pyx_r);
-  __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 690, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_INCREF(__pyx_v_defaults);
-  __Pyx_GIVEREF(__pyx_v_defaults);
-  PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_defaults);
-  __Pyx_INCREF(__pyx_v_documentation);
-  __Pyx_GIVEREF(__pyx_v_documentation);
-  PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_v_documentation);
-  __pyx_r = __pyx_t_2;
-  __pyx_t_2 = 0;
-  goto __pyx_L0;
+  /*else*/ {
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_t_7 = PyObject_Length(__pyx_v_ret); if (unlikely(__pyx_t_7 == ((Py_ssize_t)-1))) __PYX_ERR(2, 397, __pyx_L1_error)
+    __pyx_t_2 = (__pyx_t_7 == 1);
+    if (__pyx_t_2) {
+      __pyx_t_11 = __Pyx_GetItemInt(__pyx_v_ret, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1); if (unlikely(!__pyx_t_11)) __PYX_ERR(2, 397, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_11);
+      __pyx_t_9 = __pyx_t_11;
+      __pyx_t_11 = 0;
+    } else {
+      __Pyx_INCREF(__pyx_v_ret);
+      __pyx_t_9 = __pyx_v_ret;
+    }
+    __pyx_r = __pyx_t_9;
+    __pyx_t_9 = 0;
+    goto __pyx_L0;
+  }
 
 
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_6);
   __Pyx_XDECREF(__pyx_t_8);
   __Pyx_XDECREF(__pyx_t_9);
   __Pyx_XDECREF(__pyx_t_10);
-  __Pyx_AddTraceback("talib._ta_lib._get_defaults_and_docs", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_XDECREF(__pyx_t_11);
+  __Pyx_AddTraceback("talib._ta_lib.Function.outputs", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF(__pyx_v_defaults);
-  __Pyx_XDECREF(__pyx_v_func_line);
-  __Pyx_XDECREF(__pyx_v_func_args);
-  __Pyx_XDECREF(__pyx_v_docs);
-  __Pyx_XDECREF(__pyx_v_input_names);
-  __Pyx_XDECREF(__pyx_v_input_name);
-  __Pyx_XDECREF(__pyx_v_value);
-  __Pyx_XDECREF(__pyx_v_params);
-  __Pyx_XDECREF(__pyx_v_param);
-  __Pyx_XDECREF(__pyx_v_outputs);
-  __Pyx_XDECREF(__pyx_v_output);
-  __Pyx_XDECREF(__pyx_v_documentation);
+  __Pyx_XDECREF(__pyx_v_local);
+  __Pyx_XDECREF(__pyx_v_ret);
+  __Pyx_XDECREF(__pyx_v_index);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
 
-static TA_FuncHandle *__pyx_f_5talib_7_ta_lib___ta_getFuncHandle(char *__pyx_v_function_name) {
-  TA_FuncHandle *__pyx_v_handle;
-  TA_FuncHandle *__pyx_r;
+/* Python wrapper */
+static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_31run(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_8Function_30run, "Function.run(self, input_arrays=None)\n\nrun([input_arrays=None])\n\nThis is a shortcut to the outputs property that also allows setting\nthe input_arrays dict.");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_8Function_31run = {"run", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_8Function_31run, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_8Function_30run};
+static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_31run(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyObject *__pyx_v_self = 0;
+  PyObject *__pyx_v_input_arrays = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
-  __Pyx_RefNannySetupContext("__ta_getFuncHandle", 0);
-
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_GetFuncHandle, TA_GetFuncHandle(__pyx_v_function_name, (&__pyx_v_handle)), 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 706, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-
-  __pyx_r = __pyx_v_handle;
-  goto __pyx_L0;
-
+  __Pyx_RefNannySetupContext("run (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,&__pyx_mstate_global->__pyx_n_u_input_arrays,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(2, 399, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(2, 399, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 399, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "run", 0) < (0)) __PYX_ERR(2, 399, __pyx_L3_error)
+      if (!values[1]) values[1] = __Pyx_NewRef(((PyObject *)Py_None));
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("run", 0, 1, 2, i); __PYX_ERR(2, 399, __pyx_L3_error) }
+      }
+    } else {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(2, 399, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 399, __pyx_L3_error)
+        break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      if (!values[1]) values[1] = __Pyx_NewRef(((PyObject *)Py_None));
+    }
+    __pyx_v_self = values[0];
+    __pyx_v_input_arrays = values[1];
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("run", 0, 1, 2, __pyx_nargs); __PYX_ERR(2, 399, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.Function.run", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_8Function_30run(__pyx_self, __pyx_v_self, __pyx_v_input_arrays);
 
   /* function exit code */
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_WriteUnraisable("talib._ta_lib.__ta_getFuncHandle", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0);
-  __pyx_r = 0;
-  __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-
-static TA_ParamHolder *__pyx_f_5talib_7_ta_lib___ta_paramHolderAlloc(char *__pyx_v_function_name) {
-  TA_ParamHolder *__pyx_v_holder;
-  TA_RetCode __pyx_v_retCode;
-  TA_ParamHolder *__pyx_r;
+static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_30run(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_input_arrays) {
+  PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
-  __Pyx_RefNannySetupContext("__ta_paramHolderAlloc", 0);
+  int __pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  size_t __pyx_t_4;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("run", 0);
 
-  __pyx_v_retCode = TA_ParamHolderAlloc(__pyx_f_5talib_7_ta_lib___ta_getFuncHandle(__pyx_v_function_name), (&__pyx_v_holder));
+  __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_input_arrays); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(2, 406, __pyx_L1_error)
+  if (__pyx_t_1) {
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_ParamHolderAlloc, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 715, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __pyx_t_3 = __pyx_v_self;
+    __Pyx_INCREF(__pyx_t_3);
+    __pyx_t_4 = 0;
+    {
+      PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_input_arrays};
+      __pyx_t_2 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_set_input_arrays, __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+      if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 407, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+    }
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_r = __pyx_v_holder;
+  }
+
+  __pyx_t_3 = __pyx_v_self;
+  __Pyx_INCREF(__pyx_t_3);
+  __pyx_t_4 = 0;
+  {
+    PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL};
+    __pyx_t_2 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_Function__call_function, __pyx_callargs+__pyx_t_4, (1-__pyx_t_4) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+    if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 408, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+  }
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_outputs); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 409, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_r = __pyx_t_2;
+  __pyx_t_2 = 0;
   goto __pyx_L0;
 
 
   /* function exit code */
   __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_WriteUnraisable("talib._ta_lib.__ta_paramHolderAlloc", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0);
-  __pyx_r = 0;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("talib._ta_lib.Function.run", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
   __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
 
-static int __pyx_f_5talib_7_ta_lib___ta_paramHolderFree(TA_ParamHolder *__pyx_v_params) {
-  int __pyx_r;
+/* Python wrapper */
+static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_33__call__(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_8Function_32__call__, "Function.__call__(self, *args, **kwargs)\n\nfunc_instance([input_arrays,] [parameter_args,] [input_price_series_kwargs,] [parameter_kwargs])\n\nThis is a shortcut to the outputs property that also allows setting\nthe input_arrays dict and function parameters.");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_8Function_33__call__ = {"__call__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_8Function_33__call__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_8Function_32__call__};
+static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_33__call__(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyObject *__pyx_v_self = 0;
+  PyObject *__pyx_v_args = 0;
+  PyObject *__pyx_v_kwargs = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
-  __Pyx_RefNannySetupContext("__ta_paramHolderFree", 0);
-
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_ParamHolderFree, TA_ParamHolderFree(__pyx_v_params), 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 723, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-
+  __Pyx_RefNannySetupContext("__call__ (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  __pyx_v_kwargs = PyDict_New(); if (unlikely(!__pyx_v_kwargs)) return NULL;
+  __Pyx_GOTREF(__pyx_v_kwargs);
+  __pyx_v_args = __Pyx_ArgsSlice_FASTCALL(__pyx_args, 1, __pyx_nargs);
+  if (unlikely(!__pyx_v_args)) {
+    __Pyx_DECREF(__pyx_v_kwargs); __pyx_v_kwargs = 0;
+    __Pyx_RefNannyFinishContext();
+    return NULL;
+  }
+  __Pyx_GOTREF(__pyx_v_args);
+  {
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(2, 411, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        default:
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 411, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+      }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      const Py_ssize_t used_pos_args = (kwd_pos_args < 1) ? kwd_pos_args : 1;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, __pyx_v_kwargs, values, used_pos_args, __pyx_kwds_len, "__call__", 1) < (0)) __PYX_ERR(2, 411, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__call__", 0, 1, 1, i); __PYX_ERR(2, 411, __pyx_L3_error) }
+      }
+    } else if (unlikely(__pyx_nargs < 1)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 411, __pyx_L3_error)
+    }
+    __pyx_v_self = values[0];
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("__call__", 0, 1, 1, __pyx_nargs); __PYX_ERR(2, 411, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_DECREF(__pyx_v_args); __pyx_v_args = 0;
+  __Pyx_DECREF(__pyx_v_kwargs); __pyx_v_kwargs = 0;
+  __Pyx_AddTraceback("talib._ta_lib.Function.__call__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_8Function_32__call__(__pyx_self, __pyx_v_self, __pyx_v_args, __pyx_v_kwargs);
 
   /* function exit code */
-  __pyx_r = 0;
-  goto __pyx_L0;
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_WriteUnraisable("talib._ta_lib.__ta_paramHolderFree", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0);
-  __pyx_r = 0;
-  __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_DECREF(__pyx_v_args);
+  __Pyx_DECREF(__pyx_v_kwargs);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-
-static int __pyx_f_5talib_7_ta_lib___ta_setOptInputParamInteger(TA_ParamHolder *__pyx_v_holder, int __pyx_v_idx, int __pyx_v_value) {
-  TA_RetCode __pyx_v_retCode;
-  int __pyx_r;
+static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_32__call__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_args, PyObject *__pyx_v_kwargs) {
+  PyObject *__pyx_v_local = NULL;
+  PyObject *__pyx_v_opt_input_values = NULL;
+  PyObject *__pyx_v_price_series_name_values = NULL;
+  PyObject *__pyx_v_input_arrays = NULL;
+  PyObject *__pyx_v_input_price_series_names = NULL;
+  PyObject *__pyx_v_i = NULL;
+  PyObject *__pyx_v_arg = NULL;
+  PyObject *__pyx_v_msg = NULL;
+  PyObject *__pyx_v_no_existing_input_arrays = NULL;
+  PyObject *__pyx_v_param_name = NULL;
+  PyObject *__pyx_v_value = NULL;
+  PyObject *__pyx_v_input_name = NULL;
+  PyObject *__pyx_v_n = NULL;
+  PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  __Pyx_RefNannySetupContext("__ta_setOptInputParamInteger", 0);
-
-  __pyx_v_retCode = TA_SetOptInputParamInteger(__pyx_v_holder, __pyx_v_idx, __pyx_v_value);
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  size_t __pyx_t_5;
+  Py_ssize_t __pyx_t_6;
+  PyObject *(*__pyx_t_7)(PyObject *);
+  int __pyx_t_8;
+  int __pyx_t_9;
+  int __pyx_t_10;
+  PyObject *__pyx_t_11 = NULL;
+  PyObject *__pyx_t_12 = NULL;
+  PyObject *__pyx_t_13 = NULL;
+  int __pyx_t_14;
+  PyObject *__pyx_t_15 = NULL;
+  Py_ssize_t __pyx_t_16;
+  PyObject *__pyx_t_17 = NULL;
+  PyObject *__pyx_t_18 = NULL;
+  PyObject *__pyx_t_19[5];
+  PyObject *__pyx_t_20 = NULL;
+  PyObject *(*__pyx_t_21)(PyObject *);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__call__", 0);
+  __Pyx_INCREF(__pyx_v_args);
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_SetOptInputParamInteger, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 727, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_Function__local); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 418, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-
+  __pyx_v_local = __pyx_t_1;
+  __pyx_t_1 = 0;
 
-  /* function exit code */
-  __pyx_r = 0;
-  goto __pyx_L0;
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_WriteUnraisable("talib._ta_lib.__ta_setOptInputParamInteger", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0);
-  __pyx_r = 0;
-  __pyx_L0:;
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
+  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 420, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
 
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_opt_inputs); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 421, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_3 = __pyx_t_4;
+  __Pyx_INCREF(__pyx_t_3);
+  __pyx_t_5 = 0;
+  {
+    PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL};
+    __pyx_t_2 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_keys, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 421, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+  }
+  if (likely(PyList_CheckExact(__pyx_t_2)) || PyTuple_CheckExact(__pyx_t_2)) {
+    __pyx_t_4 = __pyx_t_2; __Pyx_INCREF(__pyx_t_4);
+    __pyx_t_6 = 0;
+    __pyx_t_7 = NULL;
+  } else {
+    __pyx_t_6 = -1; __pyx_t_4 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 421, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_7 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_4); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 421, __pyx_L1_error)
+  }
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  for (;;) {
+    if (likely(!__pyx_t_7)) {
+      if (likely(PyList_CheckExact(__pyx_t_4))) {
+        {
+          Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_4);
+          #if !CYTHON_ASSUME_SAFE_SIZE
+          if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 421, __pyx_L1_error)
+          #endif
+          if (__pyx_t_6 >= __pyx_temp) break;
+        }
+        __pyx_t_2 = __Pyx_PyList_GetItemRef(__pyx_t_4, __pyx_t_6);
+        ++__pyx_t_6;
+      } else {
+        {
+          Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_4);
+          #if !CYTHON_ASSUME_SAFE_SIZE
+          if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 421, __pyx_L1_error)
+          #endif
+          if (__pyx_t_6 >= __pyx_temp) break;
+        }
+        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+        __pyx_t_2 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_4, __pyx_t_6));
+        #else
+        __pyx_t_2 = __Pyx_PySequence_ITEM(__pyx_t_4, __pyx_t_6);
+        #endif
+        ++__pyx_t_6;
+      }
+      if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 421, __pyx_L1_error)
+    } else {
+      __pyx_t_2 = __pyx_t_7(__pyx_t_4);
+      if (unlikely(!__pyx_t_2)) {
+        PyObject* exc_type = PyErr_Occurred();
+        if (exc_type) {
+          if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(2, 421, __pyx_L1_error)
+          PyErr_Clear();
+        }
+        break;
+      }
+    }
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_XDECREF_SET(__pyx_v_param_name, __pyx_t_2);
+    __pyx_t_2 = 0;
 
-static int __pyx_f_5talib_7_ta_lib___ta_setOptInputParamReal(TA_ParamHolder *__pyx_v_holder, int __pyx_v_idx, int __pyx_v_value) {
-  TA_RetCode __pyx_v_retCode;
-  int __pyx_r;
-  __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
-  __Pyx_RefNannySetupContext("__ta_setOptInputParamReal", 0);
+    __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_opt_inputs); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 420, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_t_3 = __Pyx_PyObject_GetItem(__pyx_t_2, __pyx_v_param_name); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 420, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __pyx_t_2 = __Pyx_PyObject_Dict_GetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_value); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 420, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 420, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_INCREF(__pyx_v_param_name);
+    __Pyx_GIVEREF(__pyx_v_param_name);
+    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_param_name) != (0)) __PYX_ERR(2, 420, __pyx_L1_error);
+    __Pyx_GIVEREF(__pyx_t_2);
+    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_2) != (0)) __PYX_ERR(2, 420, __pyx_L1_error);
+    __pyx_t_2 = 0;
+    if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_3))) __PYX_ERR(2, 420, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
-  __pyx_v_retCode = TA_SetOptInputParamReal(__pyx_v_holder, __pyx_v_idx, __pyx_v_value);
+  }
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_v_opt_input_values = ((PyObject*)__pyx_t_1);
+  __pyx_t_1 = 0;
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_SetOptInputParamReal, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 731, __pyx_L1_error)
+  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 422, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_input_names); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 423, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  if (likely(PyList_CheckExact(__pyx_t_4)) || PyTuple_CheckExact(__pyx_t_4)) {
+    __pyx_t_3 = __pyx_t_4; __Pyx_INCREF(__pyx_t_3);
+    __pyx_t_6 = 0;
+    __pyx_t_7 = NULL;
+  } else {
+    __pyx_t_6 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 423, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_7 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 423, __pyx_L1_error)
+  }
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  for (;;) {
+    if (likely(!__pyx_t_7)) {
+      if (likely(PyList_CheckExact(__pyx_t_3))) {
+        {
+          Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_3);
+          #if !CYTHON_ASSUME_SAFE_SIZE
+          if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 423, __pyx_L1_error)
+          #endif
+          if (__pyx_t_6 >= __pyx_temp) break;
+        }
+        __pyx_t_4 = __Pyx_PyList_GetItemRef(__pyx_t_3, __pyx_t_6);
+        ++__pyx_t_6;
+      } else {
+        {
+          Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_3);
+          #if !CYTHON_ASSUME_SAFE_SIZE
+          if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 423, __pyx_L1_error)
+          #endif
+          if (__pyx_t_6 >= __pyx_temp) break;
+        }
+        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+        __pyx_t_4 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_6));
+        #else
+        __pyx_t_4 = __Pyx_PySequence_ITEM(__pyx_t_3, __pyx_t_6);
+        #endif
+        ++__pyx_t_6;
+      }
+      if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 423, __pyx_L1_error)
+    } else {
+      __pyx_t_4 = __pyx_t_7(__pyx_t_3);
+      if (unlikely(!__pyx_t_4)) {
+        PyObject* exc_type = PyErr_Occurred();
+        if (exc_type) {
+          if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(2, 423, __pyx_L1_error)
+          PyErr_Clear();
+        }
+        break;
+      }
+    }
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_XDECREF_SET(__pyx_v_n, __pyx_t_4);
+    __pyx_t_4 = 0;
+
+    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_input_names); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 422, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_2 = __Pyx_PyObject_GetItem(__pyx_t_4, __pyx_v_n); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 422, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __pyx_t_4 = __Pyx_PyObject_Dict_GetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_price_series); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 422, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 422, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_INCREF(__pyx_v_n);
+    __Pyx_GIVEREF(__pyx_v_n);
+    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_n) != (0)) __PYX_ERR(2, 422, __pyx_L1_error);
+    __Pyx_GIVEREF(__pyx_t_4);
+    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_4) != (0)) __PYX_ERR(2, 422, __pyx_L1_error);
+    __pyx_t_4 = 0;
+    if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_2))) __PYX_ERR(2, 422, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  /* function exit code */
-  __pyx_r = 0;
-  goto __pyx_L0;
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_WriteUnraisable("talib._ta_lib.__ta_setOptInputParamReal", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0);
-  __pyx_r = 0;
-  __pyx_L0:;
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
+  }
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_v_price_series_name_values = ((PyObject*)__pyx_t_1);
+  __pyx_t_1 = 0;
 
+  __pyx_t_1 = PySequence_List(__pyx_v_args); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 426, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_args, __pyx_t_1);
+  __pyx_t_1 = 0;
 
-static int __pyx_f_5talib_7_ta_lib___ta_getLookback(TA_ParamHolder *__pyx_v_holder) {
-  int __pyx_v_lookback;
-  TA_RetCode __pyx_v_retCode;
-  int __pyx_r;
-  __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
-  __Pyx_RefNannySetupContext("__ta_getLookback", 0);
+  __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 427, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_input_arrays = ((PyObject*)__pyx_t_1);
+  __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_GetLookback(__pyx_v_holder, (&__pyx_v_lookback));
+  __pyx_t_3 = __pyx_v_self;
+  __Pyx_INCREF(__pyx_t_3);
+  __pyx_t_5 = 0;
+  {
+    PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL};
+    __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_Function__input_price_series_na, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+    if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 428, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+  }
+  __pyx_v_input_price_series_names = __pyx_t_1;
+  __pyx_t_1 = 0;
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_GetLookback, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 736, __pyx_L1_error)
+  __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_v_args); if (unlikely((__pyx_t_9 < 0))) __PYX_ERR(2, 429, __pyx_L1_error)
+  if (__pyx_t_9) {
+  } else {
+    __pyx_t_8 = __pyx_t_9;
+    goto __pyx_L10_bool_binop_done;
+  }
+  __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_args, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 429, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_INPUT_ARRAYS_TYPES); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 429, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_9 = PyObject_IsInstance(__pyx_t_1, __pyx_t_3); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(2, 429, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_10 = (!__pyx_t_9);
+  __pyx_t_8 = __pyx_t_10;
+  __pyx_L10_bool_binop_done:;
+  if (__pyx_t_8) {
 
-  __pyx_r = __pyx_v_lookback;
-  goto __pyx_L0;
+    __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0);
+    __pyx_t_3 = __pyx_mstate_global->__pyx_int_0;
+    if (likely(PyList_CheckExact(__pyx_v_args)) || PyTuple_CheckExact(__pyx_v_args)) {
+      __pyx_t_1 = __pyx_v_args; __Pyx_INCREF(__pyx_t_1);
+      __pyx_t_6 = 0;
+      __pyx_t_7 = NULL;
+    } else {
+      __pyx_t_6 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_v_args); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 430, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __pyx_t_7 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_1); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 430, __pyx_L1_error)
+    }
+    for (;;) {
+      if (likely(!__pyx_t_7)) {
+        if (likely(PyList_CheckExact(__pyx_t_1))) {
+          {
+            Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_1);
+            #if !CYTHON_ASSUME_SAFE_SIZE
+            if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 430, __pyx_L1_error)
+            #endif
+            if (__pyx_t_6 >= __pyx_temp) break;
+          }
+          __pyx_t_2 = __Pyx_PyList_GetItemRef(__pyx_t_1, __pyx_t_6);
+          ++__pyx_t_6;
+        } else {
+          {
+            Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_1);
+            #if !CYTHON_ASSUME_SAFE_SIZE
+            if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 430, __pyx_L1_error)
+            #endif
+            if (__pyx_t_6 >= __pyx_temp) break;
+          }
+          #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+          __pyx_t_2 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_6));
+          #else
+          __pyx_t_2 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_6);
+          #endif
+          ++__pyx_t_6;
+        }
+        if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 430, __pyx_L1_error)
+      } else {
+        __pyx_t_2 = __pyx_t_7(__pyx_t_1);
+        if (unlikely(!__pyx_t_2)) {
+          PyObject* exc_type = PyErr_Occurred();
+          if (exc_type) {
+            if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(2, 430, __pyx_L1_error)
+            PyErr_Clear();
+          }
+          break;
+        }
+      }
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_XDECREF_SET(__pyx_v_arg, __pyx_t_2);
+      __pyx_t_2 = 0;
+      __Pyx_INCREF(__pyx_t_3);
+      __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_3);
+      __pyx_t_2 = __Pyx_PyLong_AddObjC(__pyx_t_3, __pyx_mstate_global->__pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 430, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_3);
+      __pyx_t_3 = __pyx_t_2;
+      __pyx_t_2 = 0;
 
+      __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_ARRAY_TYPES); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 431, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __pyx_t_8 = PyObject_IsInstance(__pyx_v_arg, __pyx_t_2); if (unlikely(__pyx_t_8 == ((int)-1))) __PYX_ERR(2, 431, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __pyx_t_10 = (!__pyx_t_8);
+      if (__pyx_t_10) {
 
-  /* function exit code */
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_WriteUnraisable("talib._ta_lib.__ta_getLookback", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0);
-  __pyx_r = 0;
-  __pyx_L0:;
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
+        goto __pyx_L13_break;
 
+      }
 
-/* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_359stream_ACOS(PyObject *__pyx_self, PyObject *__pyx_v_real); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_358stream_ACOS[] = " ACOS(real)\n\n    Vector Trigonometric ACos (Math Transform)\n\n    Inputs:\n        real: (any ndarray)\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_359stream_ACOS = {"stream_ACOS", (PyCFunction)__pyx_pw_5talib_7_ta_lib_359stream_ACOS, METH_O, __pyx_doc_5talib_7_ta_lib_358stream_ACOS};
-static PyObject *__pyx_pw_5talib_7_ta_lib_359stream_ACOS(PyObject *__pyx_self, PyObject *__pyx_v_real) {
-  PyObject *__pyx_r = 0;
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_ACOS (wrapper)", 0);
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 11, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_358stream_ACOS(__pyx_self, ((PyArrayObject *)__pyx_v_real));
+      {
+        __Pyx_PyThreadState_declare
+        __Pyx_PyThreadState_assign
+        __Pyx_ExceptionSave(&__pyx_t_11, &__pyx_t_12, &__pyx_t_13);
+        __Pyx_XGOTREF(__pyx_t_11);
+        __Pyx_XGOTREF(__pyx_t_12);
+        __Pyx_XGOTREF(__pyx_t_13);
+        /*try:*/ {
 
-  /* function exit code */
-  goto __pyx_L0;
-  __pyx_L1_error:;
-  __pyx_r = NULL;
-  __pyx_L0:;
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
+          __pyx_t_2 = __Pyx_PyObject_GetItem(__pyx_v_input_price_series_names, __pyx_v_i); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 435, __pyx_L15_error)
+          __Pyx_GOTREF(__pyx_t_2);
+          if (unlikely((PyDict_SetItem(__pyx_v_input_arrays, __pyx_t_2, __pyx_v_arg) < 0))) __PYX_ERR(2, 435, __pyx_L15_error)
+          __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_358stream_ACOS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) {
-  npy_intp __pyx_v_length;
-  TA_RetCode __pyx_v_retCode;
-  double *__pyx_v_real_data;
-  int __pyx_v_outbegidx;
-  int __pyx_v_outnbelement;
-  double __pyx_v_outreal;
-  PyObject *__pyx_r = NULL;
-  __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
-  __Pyx_RefNannySetupContext("stream_ACOS", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_real);
+        }
+        __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
+        __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
+        __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
+        goto __pyx_L22_try_end;
+        __pyx_L15_error:;
+        __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+        __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 28, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
+        __pyx_t_14 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_IndexError);
+        if (__pyx_t_14) {
+          __Pyx_AddTraceback("talib._ta_lib.Function.__call__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+          if (__Pyx_GetException(&__pyx_t_2, &__pyx_t_4, &__pyx_t_15) < 0) __PYX_ERR(2, 436, __pyx_L17_except_error)
+          __Pyx_XGOTREF(__pyx_t_2);
+          __Pyx_XGOTREF(__pyx_t_4);
+          __Pyx_XGOTREF(__pyx_t_15);
 
-  __pyx_v_real_data = ((double *)__pyx_v_real->data);
+          __pyx_t_16 = PyObject_Length(__pyx_v_input_price_series_names); if (unlikely(__pyx_t_16 == ((Py_ssize_t)-1))) __PYX_ERR(2, 438, __pyx_L17_except_error)
+          __pyx_t_17 = __Pyx_PyUnicode_From_Py_ssize_t(__pyx_t_16, 0, ' ', 'd'); if (unlikely(!__pyx_t_17)) __PYX_ERR(2, 438, __pyx_L17_except_error)
+          __Pyx_GOTREF(__pyx_t_17);
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+          __pyx_t_18 = PyUnicode_Join(__pyx_mstate_global->__pyx_kp_u__3, __pyx_v_input_price_series_names); if (unlikely(!__pyx_t_18)) __PYX_ERR(2, 439, __pyx_L17_except_error)
+          __Pyx_GOTREF(__pyx_t_18);
+          __pyx_t_19[0] = __pyx_mstate_global->__pyx_kp_u_Too_many_price_arguments_expecte;
+          __pyx_t_19[1] = __pyx_t_17;
+          __pyx_t_19[2] = __pyx_mstate_global->__pyx_kp_u__4;
+          __pyx_t_19[3] = __pyx_t_18;
+          __pyx_t_19[4] = __pyx_mstate_global->__pyx_kp_u__5;
+
+          __pyx_t_20 = __Pyx_PyUnicode_Join(__pyx_t_19, 5, 35 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_17) + 2 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_18) + 1, 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_18));
+          if (unlikely(!__pyx_t_20)) __PYX_ERR(2, 437, __pyx_L17_except_error)
+          __Pyx_GOTREF(__pyx_t_20);
+          __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
+          __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
+          __pyx_v_msg = ((PyObject*)__pyx_t_20);
+          __pyx_t_20 = 0;
 
-  __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
+          __pyx_t_18 = NULL;
+          __Pyx_INCREF(__pyx_builtin_TypeError);
+          __pyx_t_17 = __pyx_builtin_TypeError; 
+          __pyx_t_5 = 1;
+          {
+            PyObject *__pyx_callargs[2] = {__pyx_t_18, __pyx_v_msg};
+            __pyx_t_20 = __Pyx_PyObject_FastCall(__pyx_t_17, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+            __Pyx_XDECREF(__pyx_t_18); __pyx_t_18 = 0;
+            __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
+            if (unlikely(!__pyx_t_20)) __PYX_ERR(2, 440, __pyx_L17_except_error)
+            __Pyx_GOTREF(__pyx_t_20);
+          }
+          __Pyx_Raise(__pyx_t_20, 0, 0, 0);
+          __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+          __PYX_ERR(2, 440, __pyx_L17_except_error)
+        }
+        goto __pyx_L17_except_error;
 
-  __pyx_v_retCode = TA_ACOS((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
+        __pyx_L17_except_error:;
+        __Pyx_XGIVEREF(__pyx_t_11);
+        __Pyx_XGIVEREF(__pyx_t_12);
+        __Pyx_XGIVEREF(__pyx_t_13);
+        __Pyx_ExceptionReset(__pyx_t_11, __pyx_t_12, __pyx_t_13);
+        goto __pyx_L1_error;
+        __pyx_L22_try_end:;
+      }
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_ACOS, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 33, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    }
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    goto __pyx_L25_for_end;
+    __pyx_L13_break:;
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    goto __pyx_L25_for_end;
+    __pyx_L25_for_end:;
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
-  __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 34, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_r = __pyx_t_1;
-  __pyx_t_1 = 0;
-  goto __pyx_L0;
+  }
 
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_PANDAS_DATAFRAME); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 442, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_8 = (__pyx_t_3 != Py_None);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (__pyx_t_8) {
+  } else {
+    __pyx_t_10 = __pyx_t_8;
+    goto __pyx_L27_bool_binop_done;
+  }
 
-  /* function exit code */
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_ACOS", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = NULL;
-  __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_real);
-  __Pyx_XGIVEREF(__pyx_r);
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_input_arrays); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 443, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_PANDAS_DATAFRAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 443, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_8 = PyObject_IsInstance(__pyx_t_3, __pyx_t_1); if (unlikely(__pyx_t_8 == ((int)-1))) __PYX_ERR(2, 443, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_10 = __pyx_t_8;
+  __pyx_L27_bool_binop_done:;
 
+  if (__pyx_t_10) {
 
-/* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_361stream_AD(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_360stream_AD[] = " AD(high, low, close, volume)\n\n    Chaikin A/D Line (Volume Indicators)\n\n    Inputs:\n        prices: ['high', 'low', 'close', 'volume']\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_361stream_AD = {"stream_AD", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_361stream_AD, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_360stream_AD};
-static PyObject *__pyx_pw_5talib_7_ta_lib_361stream_AD(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_high = 0;
-  PyArrayObject *__pyx_v_low = 0;
-  PyArrayObject *__pyx_v_close = 0;
-  PyArrayObject *__pyx_v_volume = 0;
-  PyObject *__pyx_r = 0;
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_AD (wrapper)", 0);
-  {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,&__pyx_n_s_volume,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-        CYTHON_FALLTHROUGH;
-        case  0: break;
-        default: goto __pyx_L5_argtuple_error;
-      }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_AD", 1, 4, 4, 1); __PYX_ERR(3, 38, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_AD", 1, 4, 4, 2); __PYX_ERR(3, 38, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_volume)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_AD", 1, 4, 4, 3); __PYX_ERR(3, 38, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_AD") < 0)) __PYX_ERR(3, 38, __pyx_L3_error)
-      }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
-      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);
-    }
-    __pyx_v_high = ((PyArrayObject *)values[0]);
-    __pyx_v_low = ((PyArrayObject *)values[1]);
-    __pyx_v_close = ((PyArrayObject *)values[2]);
-    __pyx_v_volume = ((PyArrayObject *)values[3]);
-  }
-  goto __pyx_L4_argument_unpacking_done;
-  __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_AD", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 38, __pyx_L3_error)
-  __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_AD", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __Pyx_RefNannyFinishContext();
-  return NULL;
-  __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 38, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 38, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 38, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_volume), __pyx_ptype_5numpy_ndarray, 0, "volume", 0))) __PYX_ERR(3, 38, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_360stream_AD(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_volume);
+    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_input_arrays); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 444, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_empty); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 444, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __pyx_v_no_existing_input_arrays = __pyx_t_3;
+    __pyx_t_3 = 0;
 
-  /* function exit code */
-  goto __pyx_L0;
-  __pyx_L1_error:;
-  __pyx_r = NULL;
-  __pyx_L0:;
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
+    goto __pyx_L26;
+  }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_360stream_AD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, PyArrayObject *__pyx_v_volume) {
-  npy_intp __pyx_v_length;
-  TA_RetCode __pyx_v_retCode;
-  double *__pyx_v_high_data;
-  double *__pyx_v_low_data;
-  double *__pyx_v_close_data;
-  double *__pyx_v_volume_data;
-  int __pyx_v_outbegidx;
-  int __pyx_v_outnbelement;
-  double __pyx_v_outreal;
-  PyObject *__pyx_r = NULL;
-  __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
-  npy_intp __pyx_t_2;
-  __Pyx_RefNannySetupContext("stream_AD", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_high);
-  __Pyx_INCREF((PyObject *)__pyx_v_low);
-  __Pyx_INCREF((PyObject *)__pyx_v_close);
-  __Pyx_INCREF((PyObject *)__pyx_v_volume);
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_POLARS_DATAFRAME); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 445, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_8 = (__pyx_t_3 != Py_None);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (__pyx_t_8) {
+  } else {
+    __pyx_t_10 = __pyx_t_8;
+    goto __pyx_L29_bool_binop_done;
+  }
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 58, __pyx_L1_error)
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_input_arrays); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 446, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_POLARS_DATAFRAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 446, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_v_high_data = ((double *)__pyx_v_high->data);
+  __pyx_t_8 = PyObject_IsInstance(__pyx_t_3, __pyx_t_1); if (unlikely(__pyx_t_8 == ((int)-1))) __PYX_ERR(2, 446, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_10 = __pyx_t_8;
+  __pyx_L29_bool_binop_done:;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 60, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
+  if (__pyx_t_10) {
 
-  __pyx_v_low_data = ((double *)__pyx_v_low->data);
+    __pyx_t_15 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_input_arrays); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 447, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_15);
+    __pyx_t_3 = __pyx_t_15;
+    __Pyx_INCREF(__pyx_t_3);
+    __pyx_t_5 = 0;
+    {
+      PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL};
+      __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_is_empty, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
+      if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 447, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+    }
+    __pyx_v_no_existing_input_arrays = __pyx_t_1;
+    __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 62, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
+    goto __pyx_L26;
+  }
 
-  __pyx_v_close_data = ((double *)__pyx_v_close->data);
+  /*else*/ {
+    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_input_arrays); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 449, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_10 < 0))) __PYX_ERR(2, 449, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __pyx_t_1 = __Pyx_PyBool_FromLong((!(!(!__pyx_t_10)))); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 449, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_v_no_existing_input_arrays = __pyx_t_1;
+    __pyx_t_1 = 0;
+  }
+  __pyx_L26:;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_volume)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 64, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_volume, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
+  __pyx_t_6 = PyDict_Size(__pyx_v_input_arrays); if (unlikely(__pyx_t_6 == ((Py_ssize_t)-1))) __PYX_ERR(2, 451, __pyx_L1_error)
+  __pyx_t_16 = PyObject_Length(__pyx_v_input_price_series_names); if (unlikely(__pyx_t_16 == ((Py_ssize_t)-1))) __PYX_ERR(2, 451, __pyx_L1_error)
+  __pyx_t_10 = (__pyx_t_6 == __pyx_t_16);
+  if (__pyx_t_10) {
 
-  __pyx_v_volume_data = ((double *)__pyx_v_volume->data);
+    __pyx_t_15 = __pyx_v_self;
+    __Pyx_INCREF(__pyx_t_15);
+    __pyx_t_5 = 0;
+    {
+      PyObject *__pyx_callargs[2] = {__pyx_t_15, __pyx_v_input_arrays};
+      __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_set_input_arrays, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+      __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0;
+      if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 452, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+    }
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_volume); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(3, 66, __pyx_L1_error)
-  __pyx_v_length = __pyx_t_2;
+    __pyx_t_16 = PyDict_Size(__pyx_v_input_arrays); if (unlikely(__pyx_t_16 == ((Py_ssize_t)-1))) __PYX_ERR(2, 453, __pyx_L1_error)
+    __pyx_t_1 = __Pyx_PyList_GetSlice(__pyx_v_args, __pyx_t_16, PY_SSIZE_T_MAX); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 453, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF_SET(__pyx_v_args, __pyx_t_1);
+    __pyx_t_1 = 0;
 
-  __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
+    goto __pyx_L31;
+  }
 
-  __pyx_v_retCode = TA_AD((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, __pyx_v_volume_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
+  __pyx_t_16 = PyDict_Size(__pyx_v_input_arrays); if (unlikely(__pyx_t_16 == ((Py_ssize_t)-1))) __PYX_ERR(2, 454, __pyx_L1_error)
+  __pyx_t_8 = (__pyx_t_16 != 0);
+  if (!__pyx_t_8) {
+  } else {
+    __pyx_t_10 = __pyx_t_8;
+    goto __pyx_L32_bool_binop_done;
+  }
+  __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_v_no_existing_input_arrays); if (unlikely((__pyx_t_8 < 0))) __PYX_ERR(2, 454, __pyx_L1_error)
+  if (__pyx_t_8) {
+  } else {
+    __pyx_t_10 = __pyx_t_8;
+    goto __pyx_L32_bool_binop_done;
+  }
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_AD, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 69, __pyx_L1_error)
+  __pyx_t_16 = PyObject_Length(__pyx_v_args); if (unlikely(__pyx_t_16 == ((Py_ssize_t)-1))) __PYX_ERR(2, 455, __pyx_L1_error)
+  __pyx_t_8 = (!(__pyx_t_16 != 0));
+  if (!__pyx_t_8) {
+  } else {
+    __pyx_t_10 = __pyx_t_8;
+    goto __pyx_L32_bool_binop_done;
+  }
+  __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_args, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 455, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_GetModuleGlobalName(__pyx_t_15, __pyx_mstate_global->__pyx_n_u_INPUT_ARRAYS_TYPES); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 455, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_15);
+  __pyx_t_8 = PyObject_IsInstance(__pyx_t_1, __pyx_t_15); if (unlikely(__pyx_t_8 == ((int)-1))) __PYX_ERR(2, 455, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
+  __pyx_t_9 = (!__pyx_t_8);
+  __pyx_t_10 = __pyx_t_9;
+  __pyx_L32_bool_binop_done:;
 
-  __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 70, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_r = __pyx_t_1;
-  __pyx_t_1 = 0;
-  goto __pyx_L0;
-
+  if (unlikely(__pyx_t_10)) {
 
-  /* function exit code */
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_AD", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = NULL;
-  __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_high);
-  __Pyx_XDECREF((PyObject *)__pyx_v_low);
-  __Pyx_XDECREF((PyObject *)__pyx_v_close);
-  __Pyx_XDECREF((PyObject *)__pyx_v_volume);
-  __Pyx_XGIVEREF(__pyx_r);
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
+    __pyx_t_16 = PyObject_Length(__pyx_v_input_price_series_names); if (unlikely(__pyx_t_16 == ((Py_ssize_t)-1))) __PYX_ERR(2, 457, __pyx_L1_error)
+    __pyx_t_15 = __Pyx_PyUnicode_From_Py_ssize_t(__pyx_t_16, 0, ' ', 'd'); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 457, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_15);
 
+    __pyx_t_1 = PyUnicode_Join(__pyx_mstate_global->__pyx_kp_u__3, __pyx_v_input_price_series_names); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 458, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_t_19[0] = __pyx_mstate_global->__pyx_kp_u_Not_enough_price_arguments_expec;
+    __pyx_t_19[1] = __pyx_t_15;
+    __pyx_t_19[2] = __pyx_mstate_global->__pyx_kp_u__4;
+    __pyx_t_19[3] = __pyx_t_1;
+    __pyx_t_19[4] = __pyx_mstate_global->__pyx_kp_u__5;
+
+    __pyx_t_3 = __Pyx_PyUnicode_Join(__pyx_t_19, 5, 37 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_15) + 2 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_1) + 1, 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_1));
+    if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 456, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __pyx_v_msg = ((PyObject*)__pyx_t_3);
+    __pyx_t_3 = 0;
 
-/* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_363stream_ADD(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_362stream_ADD[] = " ADD(real0, real1)\n\n    Vector Arithmetic Add (Math Operators)\n\n    Inputs:\n        real0: (any ndarray)\n        real1: (any ndarray)\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_363stream_ADD = {"stream_ADD", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_363stream_ADD, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_362stream_ADD};
-static PyObject *__pyx_pw_5talib_7_ta_lib_363stream_ADD(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_real0 = 0;
-  PyArrayObject *__pyx_v_real1 = 0;
-  PyObject *__pyx_r = 0;
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_ADD (wrapper)", 0);
-  {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real0,&__pyx_n_s_real1,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);
-        CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-        CYTHON_FALLTHROUGH;
-        case  0: break;
-        default: goto __pyx_L5_argtuple_error;
-      }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real0)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real1)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_ADD", 1, 2, 2, 1); __PYX_ERR(3, 74, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_ADD") < 0)) __PYX_ERR(3, 74, __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_t_1 = NULL;
+    __Pyx_INCREF(__pyx_builtin_TypeError);
+    __pyx_t_15 = __pyx_builtin_TypeError; 
+    __pyx_t_5 = 1;
+    {
+      PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_v_msg};
+      __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_15, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+      __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+      __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
+      if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 459, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
     }
-    __pyx_v_real0 = ((PyArrayObject *)values[0]);
-    __pyx_v_real1 = ((PyArrayObject *)values[1]);
+    __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __PYX_ERR(2, 459, __pyx_L1_error)
+
   }
-  goto __pyx_L4_argument_unpacking_done;
-  __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_ADD", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 74, __pyx_L3_error)
-  __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_ADD", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __Pyx_RefNannyFinishContext();
-  return NULL;
-  __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real0), __pyx_ptype_5numpy_ndarray, 0, "real0", 0))) __PYX_ERR(3, 74, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real1), __pyx_ptype_5numpy_ndarray, 0, "real1", 0))) __PYX_ERR(3, 74, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_362stream_ADD(__pyx_self, __pyx_v_real0, __pyx_v_real1);
+  __pyx_L31:;
 
-  /* function exit code */
-  goto __pyx_L0;
-  __pyx_L1_error:;
-  __pyx_r = NULL;
-  __pyx_L0:;
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_set_function_args); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 461, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_15 = __Pyx_PySequence_Tuple(__pyx_v_args); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 461, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_15);
+  __pyx_t_1 = PyDict_Copy(__pyx_v_kwargs); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 461, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_15, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 461, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_362stream_ADD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real0, PyArrayObject *__pyx_v_real1) {
-  npy_intp __pyx_v_length;
-  TA_RetCode __pyx_v_retCode;
-  double *__pyx_v_real0_data;
-  double *__pyx_v_real1_data;
-  int __pyx_v_outbegidx;
-  int __pyx_v_outnbelement;
-  double __pyx_v_outreal;
-  PyObject *__pyx_r = NULL;
-  __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
-  npy_intp __pyx_t_2;
-  __Pyx_RefNannySetupContext("stream_ADD", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_real0);
-  __Pyx_INCREF((PyObject *)__pyx_v_real1);
+  __pyx_t_1 = __pyx_v_self;
+  __Pyx_INCREF(__pyx_t_1);
+  __pyx_t_5 = 0;
+  {
+    PyObject *__pyx_callargs[2] = {__pyx_t_1, NULL};
+    __pyx_t_4 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_Function__call_function, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+    if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 462, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+  }
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 93, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_real0, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
+  __pyx_t_4 = __pyx_v_opt_input_values; __Pyx_INCREF(__pyx_t_4);
+  __pyx_t_16 = 0;
+  for (;;) {
+    {
+      Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_4);
+      #if !CYTHON_ASSUME_SAFE_SIZE
+      if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 465, __pyx_L1_error)
+      #endif
+      if (__pyx_t_16 >= __pyx_temp) break;
+    }
+    __pyx_t_1 = __Pyx_PyList_GetItemRef(__pyx_t_4, __pyx_t_16);
+    ++__pyx_t_16;
+    if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 465, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    if ((likely(PyTuple_CheckExact(__pyx_t_1))) || (PyList_CheckExact(__pyx_t_1))) {
+      PyObject* sequence = __pyx_t_1;
+      Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
+      if (unlikely(size != 2)) {
+        if (size > 2) __Pyx_RaiseTooManyValuesError(2);
+        else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
+        __PYX_ERR(2, 465, __pyx_L1_error)
+      }
+      #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+      if (likely(PyTuple_CheckExact(sequence))) {
+        __pyx_t_15 = PyTuple_GET_ITEM(sequence, 0);
+        __Pyx_INCREF(__pyx_t_15);
+        __pyx_t_3 = PyTuple_GET_ITEM(sequence, 1);
+        __Pyx_INCREF(__pyx_t_3);
+      } else {
+        __pyx_t_15 = __Pyx_PyList_GetItemRef(sequence, 0);
+        if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 465, __pyx_L1_error)
+        __Pyx_XGOTREF(__pyx_t_15);
+        __pyx_t_3 = __Pyx_PyList_GetItemRef(sequence, 1);
+        if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 465, __pyx_L1_error)
+        __Pyx_XGOTREF(__pyx_t_3);
+      }
+      #else
+      __pyx_t_15 = __Pyx_PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 465, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_15);
+      __pyx_t_3 = __Pyx_PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 465, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      #endif
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    } else {
+      Py_ssize_t index = -1;
+      __pyx_t_2 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 465, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+      __pyx_t_21 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_2);
+      index = 0; __pyx_t_15 = __pyx_t_21(__pyx_t_2); if (unlikely(!__pyx_t_15)) goto __pyx_L38_unpacking_failed;
+      __Pyx_GOTREF(__pyx_t_15);
+      index = 1; __pyx_t_3 = __pyx_t_21(__pyx_t_2); if (unlikely(!__pyx_t_3)) goto __pyx_L38_unpacking_failed;
+      __Pyx_GOTREF(__pyx_t_3);
+      if (__Pyx_IternextUnpackEndCheck(__pyx_t_21(__pyx_t_2), 2) < (0)) __PYX_ERR(2, 465, __pyx_L1_error)
+      __pyx_t_21 = NULL;
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+      goto __pyx_L39_unpacking_done;
+      __pyx_L38_unpacking_failed:;
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __pyx_t_21 = NULL;
+      if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
+      __PYX_ERR(2, 465, __pyx_L1_error)
+      __pyx_L39_unpacking_done:;
+    }
+    __Pyx_XDECREF_SET(__pyx_v_param_name, __pyx_t_15);
+    __pyx_t_15 = 0;
+    __Pyx_XDECREF_SET(__pyx_v_value, __pyx_t_3);
+    __pyx_t_3 = 0;
 
-  __pyx_v_real0_data = ((double *)__pyx_v_real0->data);
+    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_opt_inputs); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 466, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_t_3 = __Pyx_PyObject_GetItem(__pyx_t_1, __pyx_v_param_name); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 466, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    if (unlikely((PyObject_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_value, __pyx_v_value) < 0))) __PYX_ERR(2, 466, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 95, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_real1, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
+  }
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
 
-  __pyx_v_real1_data = ((double *)__pyx_v_real1->data);
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_parameters); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 467, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_info); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 467, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (unlikely((PyObject_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_parameters, __pyx_t_4) < 0))) __PYX_ERR(2, 467, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_real0, __pyx_v_real1); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(3, 97, __pyx_L1_error)
-  __pyx_v_length = __pyx_t_2;
+  __pyx_t_4 = __pyx_v_price_series_name_values; __Pyx_INCREF(__pyx_t_4);
+  __pyx_t_16 = 0;
+  for (;;) {
+    {
+      Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_4);
+      #if !CYTHON_ASSUME_SAFE_SIZE
+      if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 470, __pyx_L1_error)
+      #endif
+      if (__pyx_t_16 >= __pyx_temp) break;
+    }
+    __pyx_t_3 = __Pyx_PyList_GetItemRef(__pyx_t_4, __pyx_t_16);
+    ++__pyx_t_16;
+    if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 470, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    if ((likely(PyTuple_CheckExact(__pyx_t_3))) || (PyList_CheckExact(__pyx_t_3))) {
+      PyObject* sequence = __pyx_t_3;
+      Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
+      if (unlikely(size != 2)) {
+        if (size > 2) __Pyx_RaiseTooManyValuesError(2);
+        else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
+        __PYX_ERR(2, 470, __pyx_L1_error)
+      }
+      #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+      if (likely(PyTuple_CheckExact(sequence))) {
+        __pyx_t_1 = PyTuple_GET_ITEM(sequence, 0);
+        __Pyx_INCREF(__pyx_t_1);
+        __pyx_t_15 = PyTuple_GET_ITEM(sequence, 1);
+        __Pyx_INCREF(__pyx_t_15);
+      } else {
+        __pyx_t_1 = __Pyx_PyList_GetItemRef(sequence, 0);
+        if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 470, __pyx_L1_error)
+        __Pyx_XGOTREF(__pyx_t_1);
+        __pyx_t_15 = __Pyx_PyList_GetItemRef(sequence, 1);
+        if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 470, __pyx_L1_error)
+        __Pyx_XGOTREF(__pyx_t_15);
+      }
+      #else
+      __pyx_t_1 = __Pyx_PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 470, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __pyx_t_15 = __Pyx_PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 470, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_15);
+      #endif
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    } else {
+      Py_ssize_t index = -1;
+      __pyx_t_2 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 470, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __pyx_t_21 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_2);
+      index = 0; __pyx_t_1 = __pyx_t_21(__pyx_t_2); if (unlikely(!__pyx_t_1)) goto __pyx_L43_unpacking_failed;
+      __Pyx_GOTREF(__pyx_t_1);
+      index = 1; __pyx_t_15 = __pyx_t_21(__pyx_t_2); if (unlikely(!__pyx_t_15)) goto __pyx_L43_unpacking_failed;
+      __Pyx_GOTREF(__pyx_t_15);
+      if (__Pyx_IternextUnpackEndCheck(__pyx_t_21(__pyx_t_2), 2) < (0)) __PYX_ERR(2, 470, __pyx_L1_error)
+      __pyx_t_21 = NULL;
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+      goto __pyx_L44_unpacking_done;
+      __pyx_L43_unpacking_failed:;
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __pyx_t_21 = NULL;
+      if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
+      __PYX_ERR(2, 470, __pyx_L1_error)
+      __pyx_L44_unpacking_done:;
+    }
+    __Pyx_XDECREF_SET(__pyx_v_input_name, __pyx_t_1);
+    __pyx_t_1 = 0;
+    __Pyx_XDECREF_SET(__pyx_v_value, __pyx_t_15);
+    __pyx_t_15 = 0;
 
-  __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_input_names); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 471, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_15 = __Pyx_PyObject_GetItem(__pyx_t_3, __pyx_v_input_name); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 471, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_15);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    if (unlikely((PyObject_SetItem(__pyx_t_15, __pyx_mstate_global->__pyx_n_u_price_series, __pyx_v_value) < 0))) __PYX_ERR(2, 471, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
 
-  __pyx_v_retCode = TA_ADD((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real0_data, __pyx_v_real1_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
+    __pyx_t_15 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_info); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 472, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_15);
+    __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_t_15, __pyx_mstate_global->__pyx_n_u_input_names); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 472, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
+    if (unlikely((PyObject_SetItem(__pyx_t_3, __pyx_v_input_name, __pyx_v_value) < 0))) __PYX_ERR(2, 472, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_ADD, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 100, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  }
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 101, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_r = __pyx_t_1;
-  __pyx_t_1 = 0;
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_outputs); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 474, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_r = __pyx_t_4;
+  __pyx_t_4 = 0;
   goto __pyx_L0;
 
 
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_ADD", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_15);
+  __Pyx_XDECREF(__pyx_t_17);
+  __Pyx_XDECREF(__pyx_t_18);
+  __Pyx_XDECREF(__pyx_t_20);
+  __Pyx_AddTraceback("talib._ta_lib.Function.__call__", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_real0);
-  __Pyx_XDECREF((PyObject *)__pyx_v_real1);
+  __Pyx_XDECREF(__pyx_v_args);
+  __Pyx_XDECREF(__pyx_v_local);
+  __Pyx_XDECREF(__pyx_v_opt_input_values);
+  __Pyx_XDECREF(__pyx_v_price_series_name_values);
+  __Pyx_XDECREF(__pyx_v_input_arrays);
+  __Pyx_XDECREF(__pyx_v_input_price_series_names);
+  __Pyx_XDECREF(__pyx_v_i);
+  __Pyx_XDECREF(__pyx_v_arg);
+  __Pyx_XDECREF(__pyx_v_msg);
+  __Pyx_XDECREF(__pyx_v_no_existing_input_arrays);
+  __Pyx_XDECREF(__pyx_v_param_name);
+  __Pyx_XDECREF(__pyx_v_value);
+  __Pyx_XDECREF(__pyx_v_input_name);
+  __Pyx_XDECREF(__pyx_v_n);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -38713,209 +46440,279 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_362stream_ADD(CYTHON_UNUSED PyObject *
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_365stream_ADOSC(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_364stream_ADOSC[] = " ADOSC(high, low, close, volume[, fastperiod=?, slowperiod=?])\n\n    Chaikin A/D Oscillator (Volume Indicators)\n\n    Inputs:\n        prices: ['high', 'low', 'close', 'volume']\n    Parameters:\n        fastperiod: 3\n        slowperiod: 10\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_365stream_ADOSC = {"stream_ADOSC", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_365stream_ADOSC, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_364stream_ADOSC};
-static PyObject *__pyx_pw_5talib_7_ta_lib_365stream_ADOSC(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_high = 0;
-  PyArrayObject *__pyx_v_low = 0;
-  PyArrayObject *__pyx_v_close = 0;
-  PyArrayObject *__pyx_v_volume = 0;
-  int __pyx_v_fastperiod;
-  int __pyx_v_slowperiod;
+static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_35__input_price_series_names(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_8Function_34__input_price_series_names, "Function.__input_price_series_names(self)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_8Function_35__input_price_series_names = {"__input_price_series_names", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_8Function_35__input_price_series_names, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_8Function_34__input_price_series_names};
+static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_35__input_price_series_names(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyObject *__pyx_v_self = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_ADOSC (wrapper)", 0);
+  __Pyx_RefNannySetupContext("__input_price_series_names (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,&__pyx_n_s_volume,&__pyx_n_s_fastperiod,&__pyx_n_s_slowperiod,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);
-        CYTHON_FALLTHROUGH;
-        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
-        CYTHON_FALLTHROUGH;
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(2, 477, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 477, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_ADOSC", 0, 4, 6, 1); __PYX_ERR(3, 105, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_ADOSC", 0, 4, 6, 2); __PYX_ERR(3, 105, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_volume)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_ADOSC", 0, 4, 6, 3); __PYX_ERR(3, 105, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  4:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_fastperiod);
-          if (value) { values[4] = value; kw_args--; }
-        }
-        CYTHON_FALLTHROUGH;
-        case  5:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_slowperiod);
-          if (value) { values[5] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_ADOSC") < 0)) __PYX_ERR(3, 105, __pyx_L3_error)
-      }
-    } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
-        CYTHON_FALLTHROUGH;
-        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
-        CYTHON_FALLTHROUGH;
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-        break;
-        default: goto __pyx_L5_argtuple_error;
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__input_price_series_names", 0) < (0)) __PYX_ERR(2, 477, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__input_price_series_names", 1, 1, 1, i); __PYX_ERR(2, 477, __pyx_L3_error) }
       }
-    }
-    __pyx_v_high = ((PyArrayObject *)values[0]);
-    __pyx_v_low = ((PyArrayObject *)values[1]);
-    __pyx_v_close = ((PyArrayObject *)values[2]);
-    __pyx_v_volume = ((PyArrayObject *)values[3]);
-    if (values[4]) {
-      __pyx_v_fastperiod = __Pyx_PyInt_As_int(values[4]); if (unlikely((__pyx_v_fastperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 105, __pyx_L3_error)
-    } else {
-      __pyx_v_fastperiod = ((int)-2147483648);
-    }
-    if (values[5]) {
-      __pyx_v_slowperiod = __Pyx_PyInt_As_int(values[5]); if (unlikely((__pyx_v_slowperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 105, __pyx_L3_error)
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
     } else {
-      __pyx_v_slowperiod = ((int)-2147483648);
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 477, __pyx_L3_error)
     }
+    __pyx_v_self = values[0];
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_ADOSC", 0, 4, 6, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 105, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("__input_price_series_names", 1, 1, 1, __pyx_nargs); __PYX_ERR(2, 477, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_ADOSC", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.Function.__input_price_series_names", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 105, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 105, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 105, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_volume), __pyx_ptype_5numpy_ndarray, 0, "volume", 0))) __PYX_ERR(3, 105, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_364stream_ADOSC(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_volume, __pyx_v_fastperiod, __pyx_v_slowperiod);
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_8Function_34__input_price_series_names(__pyx_self, __pyx_v_self);
 
   /* function exit code */
-  goto __pyx_L0;
-  __pyx_L1_error:;
-  __pyx_r = NULL;
-  __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_364stream_ADOSC(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, PyArrayObject *__pyx_v_volume, int __pyx_v_fastperiod, int __pyx_v_slowperiod) {
-  npy_intp __pyx_v_length;
-  TA_RetCode __pyx_v_retCode;
-  double *__pyx_v_high_data;
-  double *__pyx_v_low_data;
-  double *__pyx_v_close_data;
-  double *__pyx_v_volume_data;
-  int __pyx_v_outbegidx;
-  int __pyx_v_outnbelement;
-  double __pyx_v_outreal;
+static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_34__input_price_series_names(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
+  PyObject *__pyx_v_local = NULL;
+  PyObject *__pyx_v_input_price_series_names = NULL;
+  PyObject *__pyx_v_input_name = NULL;
+  PyObject *__pyx_v_price_series = NULL;
+  PyObject *__pyx_v_name = NULL;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  npy_intp __pyx_t_2;
-  __Pyx_RefNannySetupContext("stream_ADOSC", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_high);
-  __Pyx_INCREF((PyObject *)__pyx_v_low);
-  __Pyx_INCREF((PyObject *)__pyx_v_close);
-  __Pyx_INCREF((PyObject *)__pyx_v_volume);
+  PyObject *__pyx_t_2 = NULL;
+  Py_ssize_t __pyx_t_3;
+  PyObject *(*__pyx_t_4)(PyObject *);
+  PyObject *__pyx_t_5 = NULL;
+  int __pyx_t_6;
+  Py_ssize_t __pyx_t_7;
+  PyObject *(*__pyx_t_8)(PyObject *);
+  int __pyx_t_9;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__input_price_series_names", 0);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 128, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_Function__local); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 478, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
+  __pyx_v_local = __pyx_t_1;
   __pyx_t_1 = 0;
 
-  __pyx_v_high_data = ((double *)__pyx_v_high->data);
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 130, __pyx_L1_error)
+  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 479, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
+  __pyx_v_input_price_series_names = ((PyObject*)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_low_data = ((double *)__pyx_v_low->data);
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 132, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_input_names); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 480, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
+  if (likely(PyList_CheckExact(__pyx_t_1)) || PyTuple_CheckExact(__pyx_t_1)) {
+    __pyx_t_2 = __pyx_t_1; __Pyx_INCREF(__pyx_t_2);
+    __pyx_t_3 = 0;
+    __pyx_t_4 = NULL;
+  } else {
+    __pyx_t_3 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 480, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_t_4 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 480, __pyx_L1_error)
+  }
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  for (;;) {
+    if (likely(!__pyx_t_4)) {
+      if (likely(PyList_CheckExact(__pyx_t_2))) {
+        {
+          Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_2);
+          #if !CYTHON_ASSUME_SAFE_SIZE
+          if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 480, __pyx_L1_error)
+          #endif
+          if (__pyx_t_3 >= __pyx_temp) break;
+        }
+        __pyx_t_1 = __Pyx_PyList_GetItemRef(__pyx_t_2, __pyx_t_3);
+        ++__pyx_t_3;
+      } else {
+        {
+          Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_2);
+          #if !CYTHON_ASSUME_SAFE_SIZE
+          if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 480, __pyx_L1_error)
+          #endif
+          if (__pyx_t_3 >= __pyx_temp) break;
+        }
+        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+        __pyx_t_1 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_3));
+        #else
+        __pyx_t_1 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_3);
+        #endif
+        ++__pyx_t_3;
+      }
+      if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 480, __pyx_L1_error)
+    } else {
+      __pyx_t_1 = __pyx_t_4(__pyx_t_2);
+      if (unlikely(!__pyx_t_1)) {
+        PyObject* exc_type = PyErr_Occurred();
+        if (exc_type) {
+          if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(2, 480, __pyx_L1_error)
+          PyErr_Clear();
+        }
+        break;
+      }
+    }
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_XDECREF_SET(__pyx_v_input_name, __pyx_t_1);
+    __pyx_t_1 = 0;
+
+    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_input_names); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 481, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_t_5 = __Pyx_PyObject_GetItem(__pyx_t_1, __pyx_v_input_name); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 481, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __pyx_t_1 = __Pyx_PyObject_Dict_GetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_price_series); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 481, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_XDECREF_SET(__pyx_v_price_series, __pyx_t_1);
+    __pyx_t_1 = 0;
 
-  __pyx_v_close_data = ((double *)__pyx_v_close->data);
+    __pyx_t_6 = PyList_Check(__pyx_v_price_series); 
+    if (__pyx_t_6) {
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_volume)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 134, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_volume, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
+      if (likely(PyList_CheckExact(__pyx_v_price_series)) || PyTuple_CheckExact(__pyx_v_price_series)) {
+        __pyx_t_1 = __pyx_v_price_series; __Pyx_INCREF(__pyx_t_1);
+        __pyx_t_7 = 0;
+        __pyx_t_8 = NULL;
+      } else {
+        __pyx_t_7 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_v_price_series); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 483, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_1);
+        __pyx_t_8 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_1); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 483, __pyx_L1_error)
+      }
+      for (;;) {
+        if (likely(!__pyx_t_8)) {
+          if (likely(PyList_CheckExact(__pyx_t_1))) {
+            {
+              Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_1);
+              #if !CYTHON_ASSUME_SAFE_SIZE
+              if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 483, __pyx_L1_error)
+              #endif
+              if (__pyx_t_7 >= __pyx_temp) break;
+            }
+            __pyx_t_5 = __Pyx_PyList_GetItemRef(__pyx_t_1, __pyx_t_7);
+            ++__pyx_t_7;
+          } else {
+            {
+              Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_1);
+              #if !CYTHON_ASSUME_SAFE_SIZE
+              if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 483, __pyx_L1_error)
+              #endif
+              if (__pyx_t_7 >= __pyx_temp) break;
+            }
+            #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+            __pyx_t_5 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_7));
+            #else
+            __pyx_t_5 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_7);
+            #endif
+            ++__pyx_t_7;
+          }
+          if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 483, __pyx_L1_error)
+        } else {
+          __pyx_t_5 = __pyx_t_8(__pyx_t_1);
+          if (unlikely(!__pyx_t_5)) {
+            PyObject* exc_type = PyErr_Occurred();
+            if (exc_type) {
+              if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(2, 483, __pyx_L1_error)
+              PyErr_Clear();
+            }
+            break;
+          }
+        }
+        __Pyx_GOTREF(__pyx_t_5);
+        __Pyx_XDECREF_SET(__pyx_v_name, __pyx_t_5);
+        __pyx_t_5 = 0;
 
-  __pyx_v_volume_data = ((double *)__pyx_v_volume->data);
+        __pyx_t_9 = __Pyx_PyList_Append(__pyx_v_input_price_series_names, __pyx_v_name); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(2, 484, __pyx_L1_error)
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_volume); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(3, 136, __pyx_L1_error)
-  __pyx_v_length = __pyx_t_2;
+      }
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
-  __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
+      goto __pyx_L5;
+    }
 
-  __pyx_v_retCode = TA_ADOSC((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, __pyx_v_volume_data, __pyx_v_fastperiod, __pyx_v_slowperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
+    /*else*/ {
+      __pyx_t_9 = __Pyx_PyList_Append(__pyx_v_input_price_series_names, __pyx_v_price_series); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(2, 486, __pyx_L1_error)
+    }
+    __pyx_L5:;
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_ADOSC, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 139, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  }
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 140, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_r = __pyx_t_1;
-  __pyx_t_1 = 0;
+  __Pyx_INCREF(__pyx_v_input_price_series_names);
+  __pyx_r = __pyx_v_input_price_series_names;
   goto __pyx_L0;
 
 
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_ADOSC", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_AddTraceback("talib._ta_lib.Function.__input_price_series_names", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_high);
-  __Pyx_XDECREF((PyObject *)__pyx_v_low);
-  __Pyx_XDECREF((PyObject *)__pyx_v_close);
-  __Pyx_XDECREF((PyObject *)__pyx_v_volume);
+  __Pyx_XDECREF(__pyx_v_local);
+  __Pyx_XDECREF(__pyx_v_input_price_series_names);
+  __Pyx_XDECREF(__pyx_v_input_name);
+  __Pyx_XDECREF(__pyx_v_price_series);
+  __Pyx_XDECREF(__pyx_v_name);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -38923,171 +46720,523 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_364stream_ADOSC(CYTHON_UNUSED PyObject
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_367stream_ADX(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_366stream_ADX[] = " ADX(high, low, close[, timeperiod=?])\n\n    Average Directional Movement Index (Momentum Indicators)\n\n    Inputs:\n        prices: ['high', 'low', 'close']\n    Parameters:\n        timeperiod: 14\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_367stream_ADX = {"stream_ADX", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_367stream_ADX, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_366stream_ADX};
-static PyObject *__pyx_pw_5talib_7_ta_lib_367stream_ADX(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_high = 0;
-  PyArrayObject *__pyx_v_low = 0;
-  PyArrayObject *__pyx_v_close = 0;
-  int __pyx_v_timeperiod;
+static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_37__call_function(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_8Function_36__call_function, "Function.__call_function(self)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_8Function_37__call_function = {"__call_function", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_8Function_37__call_function, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_8Function_36__call_function};
+static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_37__call_function(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyObject *__pyx_v_self = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_ADX (wrapper)", 0);
+  __Pyx_RefNannySetupContext("__call_function (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,&__pyx_n_s_timeperiod,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(2, 489, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 489, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_ADX", 0, 3, 4, 1); __PYX_ERR(3, 144, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_ADX", 0, 3, 4, 2); __PYX_ERR(3, 144, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod);
-          if (value) { values[3] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_ADX") < 0)) __PYX_ERR(3, 144, __pyx_L3_error)
-      }
-    } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-        break;
-        default: goto __pyx_L5_argtuple_error;
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__call_function", 0) < (0)) __PYX_ERR(2, 489, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__call_function", 1, 1, 1, i); __PYX_ERR(2, 489, __pyx_L3_error) }
       }
-    }
-    __pyx_v_high = ((PyArrayObject *)values[0]);
-    __pyx_v_low = ((PyArrayObject *)values[1]);
-    __pyx_v_close = ((PyArrayObject *)values[2]);
-    if (values[3]) {
-      __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[3]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 144, __pyx_L3_error)
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
     } else {
-      __pyx_v_timeperiod = ((int)-2147483648);
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 489, __pyx_L3_error)
     }
+    __pyx_v_self = values[0];
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_ADX", 0, 3, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 144, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("__call_function", 1, 1, 1, __pyx_nargs); __PYX_ERR(2, 489, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_ADX", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.Function.__call_function", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 144, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 144, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 144, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_366stream_ADX(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_timeperiod);
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_8Function_36__call_function(__pyx_self, __pyx_v_self);
 
   /* function exit code */
-  goto __pyx_L0;
-  __pyx_L1_error:;
-  __pyx_r = NULL;
-  __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_366stream_ADX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod) {
-  npy_intp __pyx_v_length;
-  TA_RetCode __pyx_v_retCode;
-  double *__pyx_v_high_data;
-  double *__pyx_v_low_data;
-  double *__pyx_v_close_data;
-  int __pyx_v_outbegidx;
-  int __pyx_v_outnbelement;
-  double __pyx_v_outreal;
+static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_36__call_function(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
+  PyObject *__pyx_v_local = NULL;
+  PyObject *__pyx_v_input_price_series_names = NULL;
+  PyObject *__pyx_v_args = NULL;
+  PyObject *__pyx_v_price_series = NULL;
+  PyObject *__pyx_v_series = NULL;
+  PyObject *__pyx_v_opt_input = NULL;
+  PyObject *__pyx_v_value = NULL;
+  PyObject *__pyx_v_results = NULL;
+  PyObject *__pyx_v_keys = NULL;
+  PyObject *__pyx_v_i = NULL;
+  PyObject *__pyx_v_output = NULL;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  npy_intp __pyx_t_2;
-  __Pyx_RefNannySetupContext("stream_ADX", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_high);
-  __Pyx_INCREF((PyObject *)__pyx_v_low);
-  __Pyx_INCREF((PyObject *)__pyx_v_close);
+  PyObject *__pyx_t_2 = NULL;
+  size_t __pyx_t_3;
+  Py_ssize_t __pyx_t_4;
+  PyObject *(*__pyx_t_5)(PyObject *);
+  PyObject *__pyx_t_6 = NULL;
+  int __pyx_t_7;
+  int __pyx_t_8;
+  PyObject *__pyx_t_9 = NULL;
+  PyObject *__pyx_t_10 = NULL;
+  int __pyx_t_11;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__call_function", 0);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 165, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_Function__local); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 490, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
+  __pyx_v_local = __pyx_t_1;
   __pyx_t_1 = 0;
 
-  __pyx_v_high_data = ((double *)__pyx_v_high->data);
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 167, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_2 = __pyx_v_self;
+  __Pyx_INCREF(__pyx_t_2);
+  __pyx_t_3 = 0;
+  {
+    PyObject *__pyx_callargs[2] = {__pyx_t_2, NULL};
+    __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_Function__input_price_series_na, __pyx_callargs+__pyx_t_3, (1-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+    if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 491, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+  }
+  __pyx_v_input_price_series_names = __pyx_t_1;
   __pyx_t_1 = 0;
 
-  __pyx_v_low_data = ((double *)__pyx_v_low->data);
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 169, __pyx_L1_error)
+  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 494, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
+  __pyx_v_args = ((PyObject*)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_close_data = ((double *)__pyx_v_close->data);
-
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(3, 171, __pyx_L1_error)
-  __pyx_v_length = __pyx_t_2;
-
-  __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
+  if (likely(PyList_CheckExact(__pyx_v_input_price_series_names)) || PyTuple_CheckExact(__pyx_v_input_price_series_names)) {
+    __pyx_t_1 = __pyx_v_input_price_series_names; __Pyx_INCREF(__pyx_t_1);
+    __pyx_t_4 = 0;
+    __pyx_t_5 = NULL;
+  } else {
+    __pyx_t_4 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_v_input_price_series_names); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 495, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_t_5 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 495, __pyx_L1_error)
+  }
+  for (;;) {
+    if (likely(!__pyx_t_5)) {
+      if (likely(PyList_CheckExact(__pyx_t_1))) {
+        {
+          Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_1);
+          #if !CYTHON_ASSUME_SAFE_SIZE
+          if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 495, __pyx_L1_error)
+          #endif
+          if (__pyx_t_4 >= __pyx_temp) break;
+        }
+        __pyx_t_2 = __Pyx_PyList_GetItemRef(__pyx_t_1, __pyx_t_4);
+        ++__pyx_t_4;
+      } else {
+        {
+          Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_1);
+          #if !CYTHON_ASSUME_SAFE_SIZE
+          if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 495, __pyx_L1_error)
+          #endif
+          if (__pyx_t_4 >= __pyx_temp) break;
+        }
+        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+        __pyx_t_2 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_4));
+        #else
+        __pyx_t_2 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_4);
+        #endif
+        ++__pyx_t_4;
+      }
+      if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 495, __pyx_L1_error)
+    } else {
+      __pyx_t_2 = __pyx_t_5(__pyx_t_1);
+      if (unlikely(!__pyx_t_2)) {
+        PyObject* exc_type = PyErr_Occurred();
+        if (exc_type) {
+          if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(2, 495, __pyx_L1_error)
+          PyErr_Clear();
+        }
+        break;
+      }
+    }
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_XDECREF_SET(__pyx_v_price_series, __pyx_t_2);
+    __pyx_t_2 = 0;
 
-  __pyx_v_retCode = TA_ADX((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
+    __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_input_arrays); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 496, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_t_6 = __Pyx_PyObject_GetItem(__pyx_t_2, __pyx_v_price_series); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 496, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_XDECREF_SET(__pyx_v_series, __pyx_t_6);
+    __pyx_t_6 = 0;
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_ADX, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 174, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_PANDAS_SERIES); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 497, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __pyx_t_8 = (__pyx_t_6 != Py_None);
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    if (__pyx_t_8) {
+    } else {
+      __pyx_t_7 = __pyx_t_8;
+      goto __pyx_L6_bool_binop_done;
+    }
 
-  __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 175, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_r = __pyx_t_1;
-  __pyx_t_1 = 0;
-  goto __pyx_L0;
+    __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_PANDAS_SERIES); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 498, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __pyx_t_8 = PyObject_IsInstance(__pyx_v_series, __pyx_t_6); if (unlikely(__pyx_t_8 == ((int)-1))) __PYX_ERR(2, 498, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __pyx_t_7 = __pyx_t_8;
+    __pyx_L6_bool_binop_done:;
 
+    if (__pyx_t_7) {
 
-  /* function exit code */
+      __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_series, __pyx_mstate_global->__pyx_n_u_values); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 499, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_9);
+      __pyx_t_2 = __pyx_t_9;
+      __Pyx_INCREF(__pyx_t_2);
+      __pyx_t_3 = 0;
+      {
+        PyObject *__pyx_callargs[2] = {__pyx_t_2, ((PyObject *)(&PyFloat_Type))};
+        __pyx_t_6 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_astype, __pyx_callargs+__pyx_t_3, (2-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+        __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+        if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 499, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_6);
+      }
+      __Pyx_DECREF_SET(__pyx_v_series, __pyx_t_6);
+      __pyx_t_6 = 0;
+
+      goto __pyx_L5;
+    }
+
+    __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_POLARS_SERIES); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 500, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __pyx_t_8 = (__pyx_t_6 != Py_None);
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    if (__pyx_t_8) {
+    } else {
+      __pyx_t_7 = __pyx_t_8;
+      goto __pyx_L8_bool_binop_done;
+    }
+
+    __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_POLARS_SERIES); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 501, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __pyx_t_8 = PyObject_IsInstance(__pyx_v_series, __pyx_t_6); if (unlikely(__pyx_t_8 == ((int)-1))) __PYX_ERR(2, 501, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __pyx_t_7 = __pyx_t_8;
+    __pyx_L8_bool_binop_done:;
+
+    if (__pyx_t_7) {
+
+      __pyx_t_10 = __pyx_v_series;
+      __Pyx_INCREF(__pyx_t_10);
+      __pyx_t_3 = 0;
+      {
+        PyObject *__pyx_callargs[2] = {__pyx_t_10, NULL};
+        __pyx_t_2 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_to_numpy, __pyx_callargs+__pyx_t_3, (1-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+        __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+        if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 502, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_2);
+      }
+      __pyx_t_9 = __pyx_t_2;
+      __Pyx_INCREF(__pyx_t_9);
+      __pyx_t_3 = 0;
+      {
+        PyObject *__pyx_callargs[2] = {__pyx_t_9, ((PyObject *)(&PyFloat_Type))};
+        __pyx_t_6 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_astype, __pyx_callargs+__pyx_t_3, (2-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+        __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+        __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+        if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 502, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_6);
+      }
+      __Pyx_DECREF_SET(__pyx_v_series, __pyx_t_6);
+      __pyx_t_6 = 0;
+
+    }
+    __pyx_L5:;
+
+    __pyx_t_11 = __Pyx_PyList_Append(__pyx_v_args, __pyx_v_series); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(2, 503, __pyx_L1_error)
+
+  }
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_opt_inputs); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 504, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (likely(PyList_CheckExact(__pyx_t_1)) || PyTuple_CheckExact(__pyx_t_1)) {
+    __pyx_t_6 = __pyx_t_1; __Pyx_INCREF(__pyx_t_6);
+    __pyx_t_4 = 0;
+    __pyx_t_5 = NULL;
+  } else {
+    __pyx_t_4 = -1; __pyx_t_6 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 504, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __pyx_t_5 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 504, __pyx_L1_error)
+  }
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  for (;;) {
+    if (likely(!__pyx_t_5)) {
+      if (likely(PyList_CheckExact(__pyx_t_6))) {
+        {
+          Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_6);
+          #if !CYTHON_ASSUME_SAFE_SIZE
+          if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 504, __pyx_L1_error)
+          #endif
+          if (__pyx_t_4 >= __pyx_temp) break;
+        }
+        __pyx_t_1 = __Pyx_PyList_GetItemRef(__pyx_t_6, __pyx_t_4);
+        ++__pyx_t_4;
+      } else {
+        {
+          Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_6);
+          #if !CYTHON_ASSUME_SAFE_SIZE
+          if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 504, __pyx_L1_error)
+          #endif
+          if (__pyx_t_4 >= __pyx_temp) break;
+        }
+        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+        __pyx_t_1 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_6, __pyx_t_4));
+        #else
+        __pyx_t_1 = __Pyx_PySequence_ITEM(__pyx_t_6, __pyx_t_4);
+        #endif
+        ++__pyx_t_4;
+      }
+      if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 504, __pyx_L1_error)
+    } else {
+      __pyx_t_1 = __pyx_t_5(__pyx_t_6);
+      if (unlikely(!__pyx_t_1)) {
+        PyObject* exc_type = PyErr_Occurred();
+        if (exc_type) {
+          if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(2, 504, __pyx_L1_error)
+          PyErr_Clear();
+        }
+        break;
+      }
+    }
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_XDECREF_SET(__pyx_v_opt_input, __pyx_t_1);
+    __pyx_t_1 = 0;
+
+    __pyx_t_2 = __pyx_v_self;
+    __Pyx_INCREF(__pyx_t_2);
+    __pyx_t_3 = 0;
+    {
+      PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_v_opt_input};
+      __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_Function__get_opt_input_value, __pyx_callargs+__pyx_t_3, (2-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+      if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 505, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+    }
+    __Pyx_XDECREF_SET(__pyx_v_value, __pyx_t_1);
+    __pyx_t_1 = 0;
+
+    __pyx_t_11 = __Pyx_PyList_Append(__pyx_v_args, __pyx_v_value); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(2, 506, __pyx_L1_error)
+
+  }
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+
+  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_func_object); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 509, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __pyx_t_1 = PySequence_Tuple(__pyx_v_args); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 509, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 509, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v_results = __pyx_t_2;
+  __pyx_t_2 = 0;
+
+  __pyx_t_7 = __Pyx_TypeCheck(__pyx_v_results, __pyx_mstate_global->__pyx_ptype_5numpy_ndarray); 
+  if (__pyx_t_7) {
+
+    __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_outputs); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 511, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __pyx_t_1 = __pyx_t_6;
+    __Pyx_INCREF(__pyx_t_1);
+    __pyx_t_3 = 0;
+    {
+      PyObject *__pyx_callargs[2] = {__pyx_t_1, NULL};
+      __pyx_t_2 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_keys, __pyx_callargs+__pyx_t_3, (1-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+      __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+      if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 511, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+    }
+    __pyx_v_keys = __pyx_t_2;
+    __pyx_t_2 = 0;
+
+    __pyx_t_7 = PyList_Check(__pyx_v_keys); 
+    __pyx_t_8 = (!__pyx_t_7);
+    if (__pyx_t_8) {
+
+      __pyx_t_2 = PySequence_List(__pyx_v_keys); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 513, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF_SET(__pyx_v_keys, __pyx_t_2);
+      __pyx_t_2 = 0;
+
+    }
+
+    __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_outputs); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 514, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_keys, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 514, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    if (unlikely((PyObject_SetItem(__pyx_t_2, __pyx_t_6, __pyx_v_results) < 0))) __PYX_ERR(2, 514, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+
+    goto __pyx_L14;
+  }
+
+  /*else*/ {
+    __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0);
+    __pyx_t_6 = __pyx_mstate_global->__pyx_int_0;
+    __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_outputs); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 516, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    if (likely(PyList_CheckExact(__pyx_t_2)) || PyTuple_CheckExact(__pyx_t_2)) {
+      __pyx_t_1 = __pyx_t_2; __Pyx_INCREF(__pyx_t_1);
+      __pyx_t_4 = 0;
+      __pyx_t_5 = NULL;
+    } else {
+      __pyx_t_4 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 516, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __pyx_t_5 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 516, __pyx_L1_error)
+    }
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    for (;;) {
+      if (likely(!__pyx_t_5)) {
+        if (likely(PyList_CheckExact(__pyx_t_1))) {
+          {
+            Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_1);
+            #if !CYTHON_ASSUME_SAFE_SIZE
+            if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 516, __pyx_L1_error)
+            #endif
+            if (__pyx_t_4 >= __pyx_temp) break;
+          }
+          __pyx_t_2 = __Pyx_PyList_GetItemRef(__pyx_t_1, __pyx_t_4);
+          ++__pyx_t_4;
+        } else {
+          {
+            Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_1);
+            #if !CYTHON_ASSUME_SAFE_SIZE
+            if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 516, __pyx_L1_error)
+            #endif
+            if (__pyx_t_4 >= __pyx_temp) break;
+          }
+          #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+          __pyx_t_2 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_4));
+          #else
+          __pyx_t_2 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_4);
+          #endif
+          ++__pyx_t_4;
+        }
+        if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 516, __pyx_L1_error)
+      } else {
+        __pyx_t_2 = __pyx_t_5(__pyx_t_1);
+        if (unlikely(!__pyx_t_2)) {
+          PyObject* exc_type = PyErr_Occurred();
+          if (exc_type) {
+            if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(2, 516, __pyx_L1_error)
+            PyErr_Clear();
+          }
+          break;
+        }
+      }
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_XDECREF_SET(__pyx_v_output, __pyx_t_2);
+      __pyx_t_2 = 0;
+      __Pyx_INCREF(__pyx_t_6);
+      __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_6);
+      __pyx_t_2 = __Pyx_PyLong_AddObjC(__pyx_t_6, __pyx_mstate_global->__pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 516, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_6);
+      __pyx_t_6 = __pyx_t_2;
+      __pyx_t_2 = 0;
+
+      __pyx_t_2 = __Pyx_PyObject_GetItem(__pyx_v_results, __pyx_v_i); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 517, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_outputs); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 517, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_9);
+      if (unlikely((PyObject_SetItem(__pyx_t_9, __pyx_v_output, __pyx_t_2) < 0))) __PYX_ERR(2, 517, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+    }
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  }
+  __pyx_L14:;
+
+  if (__Pyx_PyObject_SetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_outputs_valid, Py_True) < (0)) __PYX_ERR(2, 518, __pyx_L1_error)
+
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_ADX", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_9);
+  __Pyx_XDECREF(__pyx_t_10);
+  __Pyx_AddTraceback("talib._ta_lib.Function.__call_function", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_high);
-  __Pyx_XDECREF((PyObject *)__pyx_v_low);
-  __Pyx_XDECREF((PyObject *)__pyx_v_close);
+  __Pyx_XDECREF(__pyx_v_local);
+  __Pyx_XDECREF(__pyx_v_input_price_series_names);
+  __Pyx_XDECREF(__pyx_v_args);
+  __Pyx_XDECREF(__pyx_v_price_series);
+  __Pyx_XDECREF(__pyx_v_series);
+  __Pyx_XDECREF(__pyx_v_opt_input);
+  __Pyx_XDECREF(__pyx_v_value);
+  __Pyx_XDECREF(__pyx_v_results);
+  __Pyx_XDECREF(__pyx_v_keys);
+  __Pyx_XDECREF(__pyx_v_i);
+  __Pyx_XDECREF(__pyx_v_output);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -39095,171 +47244,281 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_366stream_ADX(CYTHON_UNUSED PyObject *
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_369stream_ADXR(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_368stream_ADXR[] = " ADXR(high, low, close[, timeperiod=?])\n\n    Average Directional Movement Index Rating (Momentum Indicators)\n\n    Inputs:\n        prices: ['high', 'low', 'close']\n    Parameters:\n        timeperiod: 14\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_369stream_ADXR = {"stream_ADXR", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_369stream_ADXR, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_368stream_ADXR};
-static PyObject *__pyx_pw_5talib_7_ta_lib_369stream_ADXR(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_high = 0;
-  PyArrayObject *__pyx_v_low = 0;
-  PyArrayObject *__pyx_v_close = 0;
-  int __pyx_v_timeperiod;
+static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_39__check_opt_input_value(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_8Function_38__check_opt_input_value, "Function.__check_opt_input_value(self, input_name, value)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_8Function_39__check_opt_input_value = {"__check_opt_input_value", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_8Function_39__check_opt_input_value, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_8Function_38__check_opt_input_value};
+static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_39__check_opt_input_value(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyObject *__pyx_v_self = 0;
+  PyObject *__pyx_v_input_name = 0;
+  PyObject *__pyx_v_value = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[3] = {0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_ADXR (wrapper)", 0);
+  __Pyx_RefNannySetupContext("__check_opt_input_value (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,&__pyx_n_s_timeperiod,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,&__pyx_mstate_global->__pyx_n_u_input_name,&__pyx_mstate_global->__pyx_n_u_value,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(2, 520, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(2, 520, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(2, 520, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 520, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_ADXR", 0, 3, 4, 1); __PYX_ERR(3, 179, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_ADXR", 0, 3, 4, 2); __PYX_ERR(3, 179, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod);
-          if (value) { values[3] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_ADXR") < 0)) __PYX_ERR(3, 179, __pyx_L3_error)
-      }
-    } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-        break;
-        default: goto __pyx_L5_argtuple_error;
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__check_opt_input_value", 0) < (0)) __PYX_ERR(2, 520, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 3; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__check_opt_input_value", 1, 3, 3, i); __PYX_ERR(2, 520, __pyx_L3_error) }
       }
-    }
-    __pyx_v_high = ((PyArrayObject *)values[0]);
-    __pyx_v_low = ((PyArrayObject *)values[1]);
-    __pyx_v_close = ((PyArrayObject *)values[2]);
-    if (values[3]) {
-      __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[3]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 179, __pyx_L3_error)
+    } else if (unlikely(__pyx_nargs != 3)) {
+      goto __pyx_L5_argtuple_error;
     } else {
-      __pyx_v_timeperiod = ((int)-2147483648);
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 520, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(2, 520, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(2, 520, __pyx_L3_error)
     }
+    __pyx_v_self = values[0];
+    __pyx_v_input_name = values[1];
+    __pyx_v_value = values[2];
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_ADXR", 0, 3, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 179, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("__check_opt_input_value", 1, 3, 3, __pyx_nargs); __PYX_ERR(2, 520, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_ADXR", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.Function.__check_opt_input_value", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 179, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 179, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 179, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_368stream_ADXR(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_timeperiod);
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_8Function_38__check_opt_input_value(__pyx_self, __pyx_v_self, __pyx_v_input_name, __pyx_v_value);
 
   /* function exit code */
-  goto __pyx_L0;
-  __pyx_L1_error:;
-  __pyx_r = NULL;
-  __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_368stream_ADXR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod) {
-  npy_intp __pyx_v_length;
-  TA_RetCode __pyx_v_retCode;
-  double *__pyx_v_high_data;
-  double *__pyx_v_low_data;
-  double *__pyx_v_close_data;
-  int __pyx_v_outbegidx;
-  int __pyx_v_outnbelement;
-  double __pyx_v_outreal;
+static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_38__check_opt_input_value(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_input_name, PyObject *__pyx_v_value) {
+  PyObject *__pyx_v_type_ = NULL;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  npy_intp __pyx_t_2;
-  __Pyx_RefNannySetupContext("stream_ADXR", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_high);
-  __Pyx_INCREF((PyObject *)__pyx_v_low);
-  __Pyx_INCREF((PyObject *)__pyx_v_close);
+  PyObject *__pyx_t_2 = NULL;
+  int __pyx_t_3;
+  PyObject *__pyx_t_4 = NULL;
+  int __pyx_t_5;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  PyObject *__pyx_t_8 = NULL;
+  PyObject *__pyx_t_9 = NULL;
+  PyObject *__pyx_t_10[7];
+  size_t __pyx_t_11;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__check_opt_input_value", 0);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 200, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_Function__local); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 521, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_v_high_data = ((double *)__pyx_v_high->data);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_opt_inputs); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 521, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_PyObject_GetItem(__pyx_t_2, __pyx_v_input_name); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 521, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_PyObject_Dict_GetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_type_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 521, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v_type_ = __pyx_t_2;
+  __pyx_t_2 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 202, __pyx_L1_error)
+  __Pyx_INCREF(__pyx_v_type_);
+  __pyx_t_2 = __pyx_v_type_;
+  __pyx_t_1 = __Pyx_PyLong_From_TA_OptInputParameterType(TA_OptInput_IntegerList); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 522, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
+  __pyx_t_4 = PyObject_RichCompare(__pyx_t_2, __pyx_t_1, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 522, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(2, 522, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  if (!__pyx_t_5) {
+  } else {
+    __pyx_t_3 = __pyx_t_5;
+    goto __pyx_L4_bool_binop_done;
+  }
+  __pyx_t_4 = __Pyx_PyLong_From_TA_OptInputParameterType(TA_OptInput_IntegerRange); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 522, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_1 = PyObject_RichCompare(__pyx_t_2, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 522, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(2, 522, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_3 = __pyx_t_5;
+  __pyx_L4_bool_binop_done:;
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_5 = __pyx_t_3;
+  if (__pyx_t_5) {
 
-  __pyx_v_low_data = ((double *)__pyx_v_low->data);
+    __Pyx_INCREF((PyObject *)(&PyLong_Type));
+    __Pyx_DECREF_SET(__pyx_v_type_, ((PyObject *)(&PyLong_Type)));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 204, __pyx_L1_error)
+    goto __pyx_L3;
+  }
+
+  __Pyx_INCREF(__pyx_v_type_);
+  __pyx_t_2 = __pyx_v_type_;
+  __pyx_t_1 = __Pyx_PyLong_From_TA_OptInputParameterType(TA_OptInput_RealList); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 524, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
+  __pyx_t_4 = PyObject_RichCompare(__pyx_t_2, __pyx_t_1, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 524, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(2, 524, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  if (!__pyx_t_3) {
+  } else {
+    __pyx_t_5 = __pyx_t_3;
+    goto __pyx_L6_bool_binop_done;
+  }
+  __pyx_t_4 = __Pyx_PyLong_From_TA_OptInputParameterType(TA_OptInput_RealRange); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 524, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_1 = PyObject_RichCompare(__pyx_t_2, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 524, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(2, 524, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_5 = __pyx_t_3;
+  __pyx_L6_bool_binop_done:;
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_3 = __pyx_t_5;
+  if (__pyx_t_3) {
 
-  __pyx_v_close_data = ((double *)__pyx_v_close->data);
+    __Pyx_INCREF((PyObject *)(&PyFloat_Type));
+    __Pyx_DECREF_SET(__pyx_v_type_, ((PyObject *)(&PyFloat_Type)));
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(3, 206, __pyx_L1_error)
-  __pyx_v_length = __pyx_t_2;
+  }
+  __pyx_L3:;
 
-  __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
+  __pyx_t_3 = PyObject_IsInstance(__pyx_v_value, __pyx_v_type_); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(2, 527, __pyx_L1_error)
+  if (__pyx_t_3) {
 
-  __pyx_v_retCode = TA_ADXR((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
+    __Pyx_XDECREF(__pyx_r);
+    __Pyx_INCREF(Py_True);
+    __pyx_r = Py_True;
+    goto __pyx_L0;
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_ADXR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 209, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  }
+
+  __pyx_t_3 = (__pyx_v_value != Py_None);
+  if (unlikely(__pyx_t_3)) {
+
+    __pyx_t_1 = NULL;
+    __Pyx_INCREF(__pyx_builtin_TypeError);
+    __pyx_t_4 = __pyx_builtin_TypeError; 
+
+    __pyx_t_6 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Str(__pyx_v_input_name), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 532, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_type_, __pyx_mstate_global->__pyx_n_u_name_2); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 532, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    __pyx_t_8 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Str(__pyx_t_7), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 532, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_8);
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+    __pyx_t_7 = __Pyx_PyObject_GetAttrStr(((PyObject *)Py_TYPE(__pyx_v_value)), __pyx_mstate_global->__pyx_n_u_name_2); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 532, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    __pyx_t_9 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Str(__pyx_t_7), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 532, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_9);
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+    __pyx_t_10[0] = __pyx_mstate_global->__pyx_kp_u_Invalid_parameter_value_for;
+    __pyx_t_10[1] = __pyx_t_6;
+    __pyx_t_10[2] = __pyx_mstate_global->__pyx_kp_u_expected;
+    __pyx_t_10[3] = __pyx_t_8;
+    __pyx_t_10[4] = __pyx_mstate_global->__pyx_kp_u_got;
+    __pyx_t_10[5] = __pyx_t_9;
+    __pyx_t_10[6] = __pyx_mstate_global->__pyx_kp_u__5;
+
+    __pyx_t_7 = __Pyx_PyUnicode_Join(__pyx_t_10, 7, 28 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6) + 11 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_8) + 6 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_9) + 1, 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_9));
+    if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 531, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+    __pyx_t_11 = 1;
+    {
+      PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_t_7};
+      __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_11, (2-__pyx_t_11) | (__pyx_t_11*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+      __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 530, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+    }
+    __Pyx_Raise(__pyx_t_2, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __PYX_ERR(2, 530, __pyx_L1_error)
+
+  }
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 210, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_r = __pyx_t_1;
-  __pyx_t_1 = 0;
+  __Pyx_INCREF(Py_False);
+  __pyx_r = Py_False;
   goto __pyx_L0;
 
 
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_ADXR", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_XDECREF(__pyx_t_9);
+  __Pyx_AddTraceback("talib._ta_lib.Function.__check_opt_input_value", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_high);
-  __Pyx_XDECREF((PyObject *)__pyx_v_low);
-  __Pyx_XDECREF((PyObject *)__pyx_v_close);
+  __Pyx_XDECREF(__pyx_v_type_);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -39267,157 +47526,159 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_368stream_ADXR(CYTHON_UNUSED PyObject
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_371stream_APO(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_370stream_APO[] = " APO(real[, fastperiod=?, slowperiod=?, matype=?])\n\n    Absolute Price Oscillator (Momentum Indicators)\n\n    Inputs:\n        real: (any ndarray)\n    Parameters:\n        fastperiod: 12\n        slowperiod: 26\n        matype: 0 (Simple Moving Average)\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_371stream_APO = {"stream_APO", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_371stream_APO, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_370stream_APO};
-static PyObject *__pyx_pw_5talib_7_ta_lib_371stream_APO(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_real = 0;
-  int __pyx_v_fastperiod;
-  int __pyx_v_slowperiod;
-  int __pyx_v_matype;
+static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_41__get_opt_input_value(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_8Function_40__get_opt_input_value, "Function.__get_opt_input_value(self, input_name)\n\nReturns the user-set value if there is one, otherwise the default.");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_8Function_41__get_opt_input_value = {"__get_opt_input_value", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_8Function_41__get_opt_input_value, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_8Function_40__get_opt_input_value};
+static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_41__get_opt_input_value(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyObject *__pyx_v_self = 0;
+  PyObject *__pyx_v_input_name = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_APO (wrapper)", 0);
+  __Pyx_RefNannySetupContext("__get_opt_input_value (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_fastperiod,&__pyx_n_s_slowperiod,&__pyx_n_s_matype,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,&__pyx_mstate_global->__pyx_n_u_input_name,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(2, 535, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(2, 535, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 535, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_fastperiod);
-          if (value) { values[1] = value; kw_args--; }
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_slowperiod);
-          if (value) { values[2] = value; kw_args--; }
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_matype);
-          if (value) { values[3] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_APO") < 0)) __PYX_ERR(3, 214, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__get_opt_input_value", 0) < (0)) __PYX_ERR(2, 535, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__get_opt_input_value", 1, 2, 2, i); __PYX_ERR(2, 535, __pyx_L3_error) }
       }
+    } else if (unlikely(__pyx_nargs != 2)) {
+      goto __pyx_L5_argtuple_error;
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-        break;
-        default: goto __pyx_L5_argtuple_error;
-      }
-    }
-    __pyx_v_real = ((PyArrayObject *)values[0]);
-    if (values[1]) {
-      __pyx_v_fastperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_fastperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 214, __pyx_L3_error)
-    } else {
-      __pyx_v_fastperiod = ((int)-2147483648);
-    }
-    if (values[2]) {
-      __pyx_v_slowperiod = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_slowperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 214, __pyx_L3_error)
-    } else {
-      __pyx_v_slowperiod = ((int)-2147483648);
-    }
-    if (values[3]) {
-      __pyx_v_matype = __Pyx_PyInt_As_int(values[3]); if (unlikely((__pyx_v_matype == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 214, __pyx_L3_error)
-    } else {
-      __pyx_v_matype = ((int)0);
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 535, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(2, 535, __pyx_L3_error)
     }
+    __pyx_v_self = values[0];
+    __pyx_v_input_name = values[1];
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_APO", 0, 1, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 214, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("__get_opt_input_value", 1, 2, 2, __pyx_nargs); __PYX_ERR(2, 535, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_APO", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.Function.__get_opt_input_value", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 214, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_370stream_APO(__pyx_self, __pyx_v_real, __pyx_v_fastperiod, __pyx_v_slowperiod, __pyx_v_matype);
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_8Function_40__get_opt_input_value(__pyx_self, __pyx_v_self, __pyx_v_input_name);
 
   /* function exit code */
-  goto __pyx_L0;
-  __pyx_L1_error:;
-  __pyx_r = NULL;
-  __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_370stream_APO(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_fastperiod, int __pyx_v_slowperiod, int __pyx_v_matype) {
-  npy_intp __pyx_v_length;
-  TA_RetCode __pyx_v_retCode;
-  double *__pyx_v_real_data;
-  int __pyx_v_outbegidx;
-  int __pyx_v_outnbelement;
-  double __pyx_v_outreal;
+static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_40__get_opt_input_value(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_input_name) {
+  PyObject *__pyx_v_local = NULL;
+  PyObject *__pyx_v_value = NULL;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  __Pyx_RefNannySetupContext("stream_APO", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_real);
+  PyObject *__pyx_t_2 = NULL;
+  int __pyx_t_3;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__get_opt_input_value", 0);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 235, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_Function__local); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 539, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
+  __pyx_v_local = __pyx_t_1;
   __pyx_t_1 = 0;
 
-  __pyx_v_real_data = ((double *)__pyx_v_real->data);
-
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_opt_inputs); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 540, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyObject_GetItem(__pyx_t_1, __pyx_v_input_name); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 540, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_PyObject_Dict_GetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_value); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 540, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_v_value = __pyx_t_1;
+  __pyx_t_1 = 0;
 
-  __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
+  __pyx_t_3 = (__pyx_v_value == Py_None);
+  if (__pyx_t_3) {
 
-  __pyx_v_retCode = TA_APO((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_fastperiod, __pyx_v_slowperiod, __pyx_v_matype, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
+    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_opt_inputs); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 542, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_t_2 = __Pyx_PyObject_GetItem(__pyx_t_1, __pyx_v_input_name); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 542, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __pyx_t_1 = __Pyx_PyObject_Dict_GetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_default_value); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 542, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_DECREF_SET(__pyx_v_value, __pyx_t_1);
+    __pyx_t_1 = 0;
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_APO, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 240, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  }
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 241, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_r = __pyx_t_1;
-  __pyx_t_1 = 0;
+  __Pyx_INCREF(__pyx_v_value);
+  __pyx_r = __pyx_v_value;
   goto __pyx_L0;
 
 
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_APO", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("talib._ta_lib.Function.__get_opt_input_value", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_real);
+  __Pyx_XDECREF(__pyx_v_local);
+  __Pyx_XDECREF(__pyx_v_value);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -39425,166 +47686,119 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_370stream_APO(CYTHON_UNUSED PyObject *
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_373stream_AROON(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_372stream_AROON[] = " AROON(high, low[, timeperiod=?])\n\n    Aroon (Momentum Indicators)\n\n    Inputs:\n        prices: ['high', 'low']\n    Parameters:\n        timeperiod: 14\n    Outputs:\n        aroondown\n        aroonup\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_373stream_AROON = {"stream_AROON", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_373stream_AROON, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_372stream_AROON};
-static PyObject *__pyx_pw_5talib_7_ta_lib_373stream_AROON(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_high = 0;
-  PyArrayObject *__pyx_v_low = 0;
-  int __pyx_v_timeperiod;
+static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_43__repr__(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_8Function_42__repr__, "Function.__repr__(self)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_8Function_43__repr__ = {"__repr__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_8Function_43__repr__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_8Function_42__repr__};
+static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_43__repr__(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyObject *__pyx_v_self = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_AROON (wrapper)", 0);
+  __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_timeperiod,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);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(2, 545, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 545, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_AROON", 0, 2, 3, 1); __PYX_ERR(3, 245, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod);
-          if (value) { values[2] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_AROON") < 0)) __PYX_ERR(3, 245, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__repr__", 0) < (0)) __PYX_ERR(2, 545, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__repr__", 1, 1, 1, i); __PYX_ERR(2, 545, __pyx_L3_error) }
       }
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-        break;
-        default: goto __pyx_L5_argtuple_error;
-      }
-    }
-    __pyx_v_high = ((PyArrayObject *)values[0]);
-    __pyx_v_low = ((PyArrayObject *)values[1]);
-    if (values[2]) {
-      __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 245, __pyx_L3_error)
-    } else {
-      __pyx_v_timeperiod = ((int)-2147483648);
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 545, __pyx_L3_error)
     }
+    __pyx_v_self = values[0];
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_AROON", 0, 2, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 245, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("__repr__", 1, 1, 1, __pyx_nargs); __PYX_ERR(2, 545, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_AROON", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.Function.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 245, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 245, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_372stream_AROON(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_timeperiod);
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_8Function_42__repr__(__pyx_self, __pyx_v_self);
 
   /* function exit code */
-  goto __pyx_L0;
-  __pyx_L1_error:;
-  __pyx_r = NULL;
-  __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_372stream_AROON(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, int __pyx_v_timeperiod) {
-  npy_intp __pyx_v_length;
-  TA_RetCode __pyx_v_retCode;
-  double *__pyx_v_high_data;
-  double *__pyx_v_low_data;
-  int __pyx_v_outbegidx;
-  int __pyx_v_outnbelement;
-  double __pyx_v_outaroondown;
-  double __pyx_v_outaroonup;
+static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_42__repr__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  npy_intp __pyx_t_2;
-  PyObject *__pyx_t_3 = NULL;
-  PyObject *__pyx_t_4 = NULL;
-  __Pyx_RefNannySetupContext("stream_AROON", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_high);
-  __Pyx_INCREF((PyObject *)__pyx_v_low);
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 267, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_v_high_data = ((double *)__pyx_v_high->data);
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 269, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_v_low_data = ((double *)__pyx_v_low->data);
-
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_high, __pyx_v_low); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(3, 271, __pyx_L1_error)
-  __pyx_v_length = __pyx_t_2;
-
-  __pyx_v_outaroondown = __pyx_v_5talib_7_ta_lib_NaN;
-
-  __pyx_v_outaroonup = __pyx_v_5talib_7_ta_lib_NaN;
-
-  __pyx_v_retCode = TA_AROON((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_high_data, __pyx_v_low_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outaroondown), (&__pyx_v_outaroonup));
-
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_AROON, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 275, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  PyObject *__pyx_t_2 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__repr__", 0);
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outaroondown); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 276, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_info); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 546, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_3 = PyFloat_FromDouble(__pyx_v_outaroonup); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 276, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 276, __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_r = __pyx_t_4;
-  __pyx_t_4 = 0;
+  __pyx_t_2 = __Pyx_PyUnicode_FormatSafe(__pyx_mstate_global->__pyx_kp_u_s_2, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 546, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_r = __pyx_t_2;
+  __pyx_t_2 = 0;
   goto __pyx_L0;
 
 
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_XDECREF(__pyx_t_3);
-  __Pyx_XDECREF(__pyx_t_4);
-  __Pyx_AddTraceback("talib._ta_lib.stream_AROON", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("talib._ta_lib.Function.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_high);
-  __Pyx_XDECREF((PyObject *)__pyx_v_low);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -39592,149 +47806,128 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_372stream_AROON(CYTHON_UNUSED PyObject
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_375stream_AROONOSC(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_374stream_AROONOSC[] = " AROONOSC(high, low[, timeperiod=?])\n\n    Aroon Oscillator (Momentum Indicators)\n\n    Inputs:\n        prices: ['high', 'low']\n    Parameters:\n        timeperiod: 14\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_375stream_AROONOSC = {"stream_AROONOSC", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_375stream_AROONOSC, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_374stream_AROONOSC};
-static PyObject *__pyx_pw_5talib_7_ta_lib_375stream_AROONOSC(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_high = 0;
-  PyArrayObject *__pyx_v_low = 0;
-  int __pyx_v_timeperiod;
+static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_45__unicode__(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_8Function_44__unicode__, "Function.__unicode__(self)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_8Function_45__unicode__ = {"__unicode__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_8Function_45__unicode__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_8Function_44__unicode__};
+static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_45__unicode__(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyObject *__pyx_v_self = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_AROONOSC (wrapper)", 0);
+  __Pyx_RefNannySetupContext("__unicode__ (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_timeperiod,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);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(2, 548, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 548, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_AROONOSC", 0, 2, 3, 1); __PYX_ERR(3, 280, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod);
-          if (value) { values[2] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_AROONOSC") < 0)) __PYX_ERR(3, 280, __pyx_L3_error)
-      }
-    } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-        break;
-        default: goto __pyx_L5_argtuple_error;
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__unicode__", 0) < (0)) __PYX_ERR(2, 548, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__unicode__", 1, 1, 1, i); __PYX_ERR(2, 548, __pyx_L3_error) }
       }
-    }
-    __pyx_v_high = ((PyArrayObject *)values[0]);
-    __pyx_v_low = ((PyArrayObject *)values[1]);
-    if (values[2]) {
-      __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 280, __pyx_L3_error)
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
     } else {
-      __pyx_v_timeperiod = ((int)-2147483648);
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 548, __pyx_L3_error)
     }
+    __pyx_v_self = values[0];
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_AROONOSC", 0, 2, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 280, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("__unicode__", 1, 1, 1, __pyx_nargs); __PYX_ERR(2, 548, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_AROONOSC", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.Function.__unicode__", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 280, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 280, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_374stream_AROONOSC(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_timeperiod);
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_8Function_44__unicode__(__pyx_self, __pyx_v_self);
 
   /* function exit code */
-  goto __pyx_L0;
-  __pyx_L1_error:;
-  __pyx_r = NULL;
-  __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_374stream_AROONOSC(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, int __pyx_v_timeperiod) {
-  npy_intp __pyx_v_length;
-  TA_RetCode __pyx_v_retCode;
-  double *__pyx_v_high_data;
-  double *__pyx_v_low_data;
-  int __pyx_v_outbegidx;
-  int __pyx_v_outnbelement;
-  double __pyx_v_outreal;
+static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_44__unicode__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  npy_intp __pyx_t_2;
-  __Pyx_RefNannySetupContext("stream_AROONOSC", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_high);
-  __Pyx_INCREF((PyObject *)__pyx_v_low);
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 300, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_v_high_data = ((double *)__pyx_v_high->data);
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 302, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_v_low_data = ((double *)__pyx_v_low->data);
-
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_high, __pyx_v_low); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(3, 304, __pyx_L1_error)
-  __pyx_v_length = __pyx_t_2;
-
-  __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
-
-  __pyx_v_retCode = TA_AROONOSC((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_high_data, __pyx_v_low_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
-
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_AROONOSC, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 307, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  PyObject *__pyx_t_2 = NULL;
+  size_t __pyx_t_3;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__unicode__", 0);
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 308, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_r = __pyx_t_1;
-  __pyx_t_1 = 0;
+  __pyx_t_2 = __pyx_v_self;
+  __Pyx_INCREF(__pyx_t_2);
+  __pyx_t_3 = 0;
+  {
+    PyObject *__pyx_callargs[2] = {__pyx_t_2, NULL};
+    __pyx_t_1 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_str, __pyx_callargs+__pyx_t_3, (1-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+    if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 549, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+  }
+  __pyx_t_2 = __Pyx_PyObject_Unicode(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 549, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_r = __pyx_t_2;
+  __pyx_t_2 = 0;
   goto __pyx_L0;
 
 
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_AROONOSC", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("talib._ta_lib.Function.__unicode__", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_high);
-  __Pyx_XDECREF((PyObject *)__pyx_v_low);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -39742,70 +47935,148 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_374stream_AROONOSC(CYTHON_UNUSED PyObj
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_377stream_ASIN(PyObject *__pyx_self, PyObject *__pyx_v_real); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_376stream_ASIN[] = " ASIN(real)\n\n    Vector Trigonometric ASin (Math Transform)\n\n    Inputs:\n        real: (any ndarray)\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_377stream_ASIN = {"stream_ASIN", (PyCFunction)__pyx_pw_5talib_7_ta_lib_377stream_ASIN, METH_O, __pyx_doc_5talib_7_ta_lib_376stream_ASIN};
-static PyObject *__pyx_pw_5talib_7_ta_lib_377stream_ASIN(PyObject *__pyx_self, PyObject *__pyx_v_real) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_47__str__(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_8Function_46__str__, "Function.__str__(self)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_8Function_47__str__ = {"__str__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_8Function_47__str__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_8Function_46__str__};
+static PyObject *__pyx_pw_5talib_7_ta_lib_8Function_47__str__(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyObject *__pyx_v_self = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_ASIN (wrapper)", 0);
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 312, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_376stream_ASIN(__pyx_self, ((PyArrayObject *)__pyx_v_real));
+  __Pyx_RefNannySetupContext("__str__ (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_self,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(2, 551, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 551, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__str__", 0) < (0)) __PYX_ERR(2, 551, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__str__", 1, 1, 1, i); __PYX_ERR(2, 551, __pyx_L3_error) }
+      }
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 551, __pyx_L3_error)
+    }
+    __pyx_v_self = values[0];
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("__str__", 1, 1, 1, __pyx_nargs); __PYX_ERR(2, 551, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.Function.__str__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_8Function_46__str__(__pyx_self, __pyx_v_self);
 
   /* function exit code */
-  goto __pyx_L0;
-  __pyx_L1_error:;
-  __pyx_r = NULL;
-  __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_376stream_ASIN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) {
-  npy_intp __pyx_v_length;
-  TA_RetCode __pyx_v_retCode;
-  double *__pyx_v_real_data;
-  int __pyx_v_outbegidx;
-  int __pyx_v_outnbelement;
-  double __pyx_v_outreal;
+static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_46__str__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) {
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  __Pyx_RefNannySetupContext("stream_ASIN", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_real);
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 329, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_v_real_data = ((double *)__pyx_v_real->data);
-
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
-
-  __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
-
-  __pyx_v_retCode = TA_ASIN((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
-
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_ASIN, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 334, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  size_t __pyx_t_5;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__str__", 0);
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 335, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_r = __pyx_t_1;
-  __pyx_t_1 = 0;
+  __pyx_t_2 = NULL;
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_get_defaults_and_docs); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 552, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_info); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 552, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = 1;
+  #if CYTHON_UNPACK_METHODS
+  if (unlikely(PyMethod_Check(__pyx_t_3))) {
+    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3);
+    assert(__pyx_t_2);
+    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3);
+    __Pyx_INCREF(__pyx_t_2);
+    __Pyx_INCREF(__pyx__function);
+    __Pyx_DECREF_SET(__pyx_t_3, __pyx__function);
+    __pyx_t_5 = 0;
+  }
+  #endif
+  {
+    PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_t_4};
+    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 552, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+  }
+  __pyx_t_3 = __Pyx_GetItemInt(__pyx_t_1, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 552, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_r = __pyx_t_3;
+  __pyx_t_3 = 0;
   goto __pyx_L0;
 
 
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_ASIN", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_AddTraceback("talib._ta_lib.Function.__str__", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_real);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -39813,70 +48084,75 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_376stream_ASIN(CYTHON_UNUSED PyObject
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_379stream_ATAN(PyObject *__pyx_self, PyObject *__pyx_v_real); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_378stream_ATAN[] = " ATAN(real)\n\n    Vector Trigonometric ATan (Math Transform)\n\n    Inputs:\n        real: (any ndarray)\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_379stream_ATAN = {"stream_ATAN", (PyCFunction)__pyx_pw_5talib_7_ta_lib_379stream_ATAN, METH_O, __pyx_doc_5talib_7_ta_lib_378stream_ATAN};
-static PyObject *__pyx_pw_5talib_7_ta_lib_379stream_ATAN(PyObject *__pyx_self, PyObject *__pyx_v_real) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_349_ta_getGroupTable(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_348_ta_getGroupTable, "_ta_getGroupTable()\n\nReturns the list of available TALIB function group names. *slow*");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_349_ta_getGroupTable = {"_ta_getGroupTable", (PyCFunction)__pyx_pw_5talib_7_ta_lib_349_ta_getGroupTable, METH_NOARGS, __pyx_doc_5talib_7_ta_lib_348_ta_getGroupTable};
+static PyObject *__pyx_pw_5talib_7_ta_lib_349_ta_getGroupTable(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused) {
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_ATAN (wrapper)", 0);
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 339, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_378stream_ATAN(__pyx_self, ((PyArrayObject *)__pyx_v_real));
+  __Pyx_RefNannySetupContext("_ta_getGroupTable (wrapper)", 0);
+  __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs);
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_348_ta_getGroupTable(__pyx_self);
 
   /* function exit code */
-  goto __pyx_L0;
-  __pyx_L1_error:;
-  __pyx_r = NULL;
-  __pyx_L0:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_378stream_ATAN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) {
-  npy_intp __pyx_v_length;
-  TA_RetCode __pyx_v_retCode;
-  double *__pyx_v_real_data;
-  int __pyx_v_outbegidx;
-  int __pyx_v_outnbelement;
-  double __pyx_v_outreal;
+static PyObject *__pyx_pf_5talib_7_ta_lib_348_ta_getGroupTable(CYTHON_UNUSED PyObject *__pyx_self) {
+  TA_StringTable *__pyx_v_table;
+  PyObject *__pyx_v_groups = NULL;
+  unsigned int __pyx_v_i;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  __Pyx_RefNannySetupContext("stream_ATAN", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_real);
+  unsigned int __pyx_t_2;
+  unsigned int __pyx_t_3;
+  unsigned int __pyx_t_4;
+  int __pyx_t_5;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_ta_getGroupTable", 0);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 356, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_GroupTableAlloc, TA_GroupTableAlloc((&__pyx_v_table)), 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 570, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_v_real_data = ((double *)__pyx_v_real->data);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 571, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_groups = ((PyObject*)__pyx_t_1);
+  __pyx_t_1 = 0;
 
-  __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
+  __pyx_t_2 = __pyx_v_table->size;
+  __pyx_t_3 = __pyx_t_2;
+  for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) {
+    __pyx_v_i = __pyx_t_4;
 
-  __pyx_v_retCode = TA_ATAN((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
+    __pyx_t_1 = __Pyx_PyBytes_FromString((*(&(__pyx_v_table->string[__pyx_v_i])))); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 573, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_t_5 = __Pyx_PyList_Append(__pyx_v_groups, __pyx_t_1); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(2, 573, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  }
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_ATAN, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 361, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_GroupTableFree, TA_GroupTableFree(__pyx_v_table), 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 574, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 362, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_r = __pyx_t_1;
-  __pyx_t_1 = 0;
+  __Pyx_INCREF(__pyx_v_groups);
+  __pyx_r = __pyx_v_groups;
   goto __pyx_L0;
 
 
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_ATAN", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib._ta_getGroupTable", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_real);
+  __Pyx_XDECREF(__pyx_v_groups);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -39884,171 +48160,144 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_378stream_ATAN(CYTHON_UNUSED PyObject
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_381stream_ATR(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_380stream_ATR[] = " ATR(high, low, close[, timeperiod=?])\n\n    Average True Range (Volatility Indicators)\n\n    Inputs:\n        prices: ['high', 'low', 'close']\n    Parameters:\n        timeperiod: 14\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_381stream_ATR = {"stream_ATR", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_381stream_ATR, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_380stream_ATR};
-static PyObject *__pyx_pw_5talib_7_ta_lib_381stream_ATR(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_high = 0;
-  PyArrayObject *__pyx_v_low = 0;
-  PyArrayObject *__pyx_v_close = 0;
-  int __pyx_v_timeperiod;
+static PyObject *__pyx_pw_5talib_7_ta_lib_351_ta_getFuncTable(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_350_ta_getFuncTable, "_ta_getFuncTable(char *group)\n\nReturns a list of the functions for the specified group name. *slow*");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_351_ta_getFuncTable = {"_ta_getFuncTable", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_351_ta_getFuncTable, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_350_ta_getFuncTable};
+static PyObject *__pyx_pw_5talib_7_ta_lib_351_ta_getFuncTable(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  char *__pyx_v_group;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_ATR (wrapper)", 0);
+  __Pyx_RefNannySetupContext("_ta_getFuncTable (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,&__pyx_n_s_timeperiod,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_group,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(2, 577, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 577, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_ATR", 0, 3, 4, 1); __PYX_ERR(3, 366, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_ATR", 0, 3, 4, 2); __PYX_ERR(3, 366, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod);
-          if (value) { values[3] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_ATR") < 0)) __PYX_ERR(3, 366, __pyx_L3_error)
-      }
-    } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-        break;
-        default: goto __pyx_L5_argtuple_error;
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "_ta_getFuncTable", 0) < (0)) __PYX_ERR(2, 577, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("_ta_getFuncTable", 1, 1, 1, i); __PYX_ERR(2, 577, __pyx_L3_error) }
       }
-    }
-    __pyx_v_high = ((PyArrayObject *)values[0]);
-    __pyx_v_low = ((PyArrayObject *)values[1]);
-    __pyx_v_close = ((PyArrayObject *)values[2]);
-    if (values[3]) {
-      __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[3]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 366, __pyx_L3_error)
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
     } else {
-      __pyx_v_timeperiod = ((int)-2147483648);
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 577, __pyx_L3_error)
     }
+    __pyx_v_group = __Pyx_PyObject_AsWritableString(values[0]); if (unlikely((!__pyx_v_group) && PyErr_Occurred())) __PYX_ERR(2, 577, __pyx_L3_error)
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_ATR", 0, 3, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 366, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("_ta_getFuncTable", 1, 1, 1, __pyx_nargs); __PYX_ERR(2, 577, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_ATR", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib._ta_getFuncTable", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 366, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 366, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 366, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_380stream_ATR(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_timeperiod);
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_350_ta_getFuncTable(__pyx_self, __pyx_v_group);
 
   /* function exit code */
-  goto __pyx_L0;
-  __pyx_L1_error:;
-  __pyx_r = NULL;
-  __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_380stream_ATR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod) {
-  npy_intp __pyx_v_length;
-  TA_RetCode __pyx_v_retCode;
-  double *__pyx_v_high_data;
-  double *__pyx_v_low_data;
-  double *__pyx_v_close_data;
-  int __pyx_v_outbegidx;
-  int __pyx_v_outnbelement;
-  double __pyx_v_outreal;
+static PyObject *__pyx_pf_5talib_7_ta_lib_350_ta_getFuncTable(CYTHON_UNUSED PyObject *__pyx_self, char *__pyx_v_group) {
+  TA_StringTable *__pyx_v_table;
+  PyObject *__pyx_v_functions = NULL;
+  unsigned int __pyx_v_i;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  npy_intp __pyx_t_2;
-  __Pyx_RefNannySetupContext("stream_ATR", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_high);
-  __Pyx_INCREF((PyObject *)__pyx_v_low);
-  __Pyx_INCREF((PyObject *)__pyx_v_close);
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 387, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_v_high_data = ((double *)__pyx_v_high->data);
+  unsigned int __pyx_t_2;
+  unsigned int __pyx_t_3;
+  unsigned int __pyx_t_4;
+  int __pyx_t_5;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_ta_getFuncTable", 0);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 389, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_FuncTableAlloc, TA_FuncTableAlloc(__pyx_v_group, (&__pyx_v_table)), 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 582, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_v_low_data = ((double *)__pyx_v_low->data);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 391, __pyx_L1_error)
+  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 583, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
+  __pyx_v_functions = ((PyObject*)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_close_data = ((double *)__pyx_v_close->data);
-
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(3, 393, __pyx_L1_error)
-  __pyx_v_length = __pyx_t_2;
-
-  __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
+  __pyx_t_2 = __pyx_v_table->size;
+  __pyx_t_3 = __pyx_t_2;
+  for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) {
+    __pyx_v_i = __pyx_t_4;
 
-  __pyx_v_retCode = TA_ATR((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
+    __pyx_t_1 = __Pyx_PyBytes_FromString((*(&(__pyx_v_table->string[__pyx_v_i])))); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 585, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_t_5 = __Pyx_PyList_Append(__pyx_v_functions, __pyx_t_1); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(2, 585, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  }
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_ATR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 396, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_FuncTableFree, TA_FuncTableFree(__pyx_v_table), 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 586, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 397, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_r = __pyx_t_1;
-  __pyx_t_1 = 0;
+  __Pyx_INCREF(__pyx_v_functions);
+  __pyx_r = __pyx_v_functions;
   goto __pyx_L0;
 
 
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_ATR", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib._ta_getFuncTable", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_high);
-  __Pyx_XDECREF((PyObject *)__pyx_v_low);
-  __Pyx_XDECREF((PyObject *)__pyx_v_close);
+  __Pyx_XDECREF(__pyx_v_functions);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -40056,175 +48305,394 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_380stream_ATR(CYTHON_UNUSED PyObject *
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_383stream_AVGPRICE(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_382stream_AVGPRICE[] = " AVGPRICE(open, high, low, close)\n\n    Average Price (Price Transform)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_383stream_AVGPRICE = {"stream_AVGPRICE", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_383stream_AVGPRICE, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_382stream_AVGPRICE};
-static PyObject *__pyx_pw_5talib_7_ta_lib_383stream_AVGPRICE(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_open = 0;
-  PyArrayObject *__pyx_v_high = 0;
-  PyArrayObject *__pyx_v_low = 0;
-  PyArrayObject *__pyx_v_close = 0;
+static PyObject *__pyx_pw_5talib_7_ta_lib_353__get_flags(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_352__get_flags, "__get_flags(int flag, dict flags_lookup_dict)\n\nTA-LIB provides hints for multiple flags as a bitwise-ORed int.\nThis function returns the flags from flag found in the provided\nflags_lookup_dict.");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_353__get_flags = {"__get_flags", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_353__get_flags, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_352__get_flags};
+static PyObject *__pyx_pw_5talib_7_ta_lib_353__get_flags(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  int __pyx_v_flag;
+  PyObject *__pyx_v_flags_lookup_dict = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_AVGPRICE (wrapper)", 0);
+  __Pyx_RefNannySetupContext("__get_flags (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_flag,&__pyx_mstate_global->__pyx_n_u_flags_lookup_dict,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(2, 589, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(2, 589, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 589, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_AVGPRICE", 1, 4, 4, 1); __PYX_ERR(3, 401, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_AVGPRICE", 1, 4, 4, 2); __PYX_ERR(3, 401, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_AVGPRICE", 1, 4, 4, 3); __PYX_ERR(3, 401, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_AVGPRICE") < 0)) __PYX_ERR(3, 401, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__get_flags", 0) < (0)) __PYX_ERR(2, 589, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__get_flags", 1, 2, 2, i); __PYX_ERR(2, 589, __pyx_L3_error) }
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
+    } else if (unlikely(__pyx_nargs != 2)) {
       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[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 589, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(2, 589, __pyx_L3_error)
     }
-    __pyx_v_open = ((PyArrayObject *)values[0]);
-    __pyx_v_high = ((PyArrayObject *)values[1]);
-    __pyx_v_low = ((PyArrayObject *)values[2]);
-    __pyx_v_close = ((PyArrayObject *)values[3]);
+    __pyx_v_flag = __Pyx_PyLong_As_int(values[0]); if (unlikely((__pyx_v_flag == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 589, __pyx_L3_error)
+    __pyx_v_flags_lookup_dict = ((PyObject*)values[1]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_AVGPRICE", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 401, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("__get_flags", 1, 2, 2, __pyx_nargs); __PYX_ERR(2, 589, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_AVGPRICE", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.__get_flags", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 401, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 401, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 401, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 401, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_382stream_AVGPRICE(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_flags_lookup_dict), (&PyDict_Type), 1, "flags_lookup_dict", 1))) __PYX_ERR(2, 589, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_352__get_flags(__pyx_self, __pyx_v_flag, __pyx_v_flags_lookup_dict);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_382stream_AVGPRICE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
-  npy_intp __pyx_v_length;
-  TA_RetCode __pyx_v_retCode;
-  double *__pyx_v_open_data;
-  double *__pyx_v_high_data;
-  double *__pyx_v_low_data;
-  double *__pyx_v_close_data;
-  int __pyx_v_outbegidx;
-  int __pyx_v_outnbelement;
-  double __pyx_v_outreal;
+static PyObject *__pyx_pf_5talib_7_ta_lib_352__get_flags(CYTHON_UNUSED PyObject *__pyx_self, int __pyx_v_flag, PyObject *__pyx_v_flags_lookup_dict) {
+  PyObject *__pyx_v_value_range = NULL;
+  PyObject *__pyx_v_min_int = NULL;
+  PyObject *__pyx_v_max_int = NULL;
+  PyObject *__pyx_v_ret = NULL;
+  PyObject *__pyx_v_i = NULL;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  npy_intp __pyx_t_2;
-  __Pyx_RefNannySetupContext("stream_AVGPRICE", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_open);
-  __Pyx_INCREF((PyObject *)__pyx_v_high);
-  __Pyx_INCREF((PyObject *)__pyx_v_low);
-  __Pyx_INCREF((PyObject *)__pyx_v_close);
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 421, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_v_open_data = ((double *)__pyx_v_open->data);
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 423, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_v_high_data = ((double *)__pyx_v_high->data);
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 425, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_v_low_data = ((double *)__pyx_v_low->data);
+  int __pyx_t_2;
+  int __pyx_t_3;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  PyObject *__pyx_t_8 = NULL;
+  size_t __pyx_t_9;
+  Py_ssize_t __pyx_t_10;
+  PyObject *(*__pyx_t_11)(PyObject *);
+  int __pyx_t_12;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__get_flags", 0);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 427, __pyx_L1_error)
+  if (unlikely(__pyx_v_flags_lookup_dict == Py_None)) {
+    PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "keys");
+    __PYX_ERR(2, 595, __pyx_L1_error)
+  }
+  __pyx_t_1 = __Pyx_PyDict_Keys(__pyx_v_flags_lookup_dict); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 595, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
+  __pyx_v_value_range = __pyx_t_1;
   __pyx_t_1 = 0;
 
-  __pyx_v_close_data = ((double *)__pyx_v_close->data);
-
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(3, 429, __pyx_L1_error)
-  __pyx_v_length = __pyx_t_2;
+  __pyx_t_2 = PyList_Check(__pyx_v_value_range); 
+  __pyx_t_3 = (!__pyx_t_2);
+  if (__pyx_t_3) {
 
-  __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
+    __pyx_t_1 = PySequence_List(__pyx_v_value_range); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 597, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF_SET(__pyx_v_value_range, __pyx_t_1);
+    __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_AVGPRICE((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
+  }
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_AVGPRICE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 432, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_4 = NULL;
+  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_math); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 598, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_log); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 598, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_7 = NULL;
+  __Pyx_INCREF(__pyx_builtin_min);
+  __pyx_t_8 = __pyx_builtin_min; 
+  __pyx_t_9 = 1;
+  {
+    PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_v_value_range};
+    __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_8, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+    __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+    if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 598, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+  }
+  __pyx_t_9 = 1;
+  #if CYTHON_UNPACK_METHODS
+  if (unlikely(PyMethod_Check(__pyx_t_6))) {
+    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_6);
+    assert(__pyx_t_4);
+    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6);
+    __Pyx_INCREF(__pyx_t_4);
+    __Pyx_INCREF(__pyx__function);
+    __Pyx_DECREF_SET(__pyx_t_6, __pyx__function);
+    __pyx_t_9 = 0;
+  }
+  #endif
+  {
+    PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_t_5, __pyx_mstate_global->__pyx_int_2};
+    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+__pyx_t_9, (3-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 598, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+  }
+  __pyx_t_6 = __Pyx_PyNumber_Int(__pyx_t_1); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 598, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v_min_int = ((PyObject*)__pyx_t_6);
+  __pyx_t_6 = 0;
 
-  __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 433, __pyx_L1_error)
+  __pyx_t_1 = NULL;
+  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_math); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 599, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_log); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 599, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_8 = NULL;
+  __Pyx_INCREF(__pyx_builtin_max);
+  __pyx_t_7 = __pyx_builtin_max; 
+  __pyx_t_9 = 1;
+  {
+    PyObject *__pyx_callargs[2] = {__pyx_t_8, __pyx_v_value_range};
+    __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_7, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+    __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+    if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 599, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+  }
+  __pyx_t_9 = 1;
+  #if CYTHON_UNPACK_METHODS
+  if (unlikely(PyMethod_Check(__pyx_t_4))) {
+    __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_4);
+    assert(__pyx_t_1);
+    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
+    __Pyx_INCREF(__pyx_t_1);
+    __Pyx_INCREF(__pyx__function);
+    __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
+    __pyx_t_9 = 0;
+  }
+  #endif
+  {
+    PyObject *__pyx_callargs[3] = {__pyx_t_1, __pyx_t_5, __pyx_mstate_global->__pyx_int_2};
+    __pyx_t_6 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_9, (3-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 599, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+  }
+  __pyx_t_4 = __Pyx_PyNumber_Int(__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 599, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  __pyx_v_max_int = ((PyObject*)__pyx_t_4);
+  __pyx_t_4 = 0;
+
+  __pyx_t_2 = (__pyx_v_flag < 1);
+  if (!__pyx_t_2) {
+  } else {
+    __pyx_t_3 = __pyx_t_2;
+    goto __pyx_L5_bool_binop_done;
+  }
+  __pyx_t_4 = __Pyx_PyLong_From_int(__pyx_v_flag); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 602, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_6 = PyNumber_Power(__pyx_mstate_global->__pyx_int_2, __pyx_v_max_int, Py_None); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 602, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __pyx_t_5 = PyObject_RichCompare(__pyx_t_4, __pyx_t_6, Py_GT); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 602, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(2, 602, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_3 = __pyx_t_2;
+  __pyx_L5_bool_binop_done:;
+  if (__pyx_t_3) {
+
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+    goto __pyx_L0;
+
+  }
+
+  __pyx_t_5 = PyList_New(0); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 608, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_v_ret = ((PyObject*)__pyx_t_5);
+  __pyx_t_5 = 0;
+
+  __pyx_t_6 = NULL;
+  __Pyx_INCREF(__pyx_builtin_xrange);
+  __pyx_t_4 = __pyx_builtin_xrange; 
+  __pyx_t_1 = __Pyx_PyLong_AddObjC(__pyx_v_max_int, __pyx_mstate_global->__pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 609, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_r = __pyx_t_1;
-  __pyx_t_1 = 0;
+  __pyx_t_9 = 1;
+  {
+    PyObject *__pyx_callargs[3] = {__pyx_t_6, __pyx_v_min_int, __pyx_t_1};
+    __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_9, (3-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 609, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+  }
+  if (likely(PyList_CheckExact(__pyx_t_5)) || PyTuple_CheckExact(__pyx_t_5)) {
+    __pyx_t_4 = __pyx_t_5; __Pyx_INCREF(__pyx_t_4);
+    __pyx_t_10 = 0;
+    __pyx_t_11 = NULL;
+  } else {
+    __pyx_t_10 = -1; __pyx_t_4 = PyObject_GetIter(__pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 609, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_11 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_4); if (unlikely(!__pyx_t_11)) __PYX_ERR(2, 609, __pyx_L1_error)
+  }
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  for (;;) {
+    if (likely(!__pyx_t_11)) {
+      if (likely(PyList_CheckExact(__pyx_t_4))) {
+        {
+          Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_4);
+          #if !CYTHON_ASSUME_SAFE_SIZE
+          if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 609, __pyx_L1_error)
+          #endif
+          if (__pyx_t_10 >= __pyx_temp) break;
+        }
+        __pyx_t_5 = __Pyx_PyList_GetItemRef(__pyx_t_4, __pyx_t_10);
+        ++__pyx_t_10;
+      } else {
+        {
+          Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_4);
+          #if !CYTHON_ASSUME_SAFE_SIZE
+          if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 609, __pyx_L1_error)
+          #endif
+          if (__pyx_t_10 >= __pyx_temp) break;
+        }
+        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+        __pyx_t_5 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_4, __pyx_t_10));
+        #else
+        __pyx_t_5 = __Pyx_PySequence_ITEM(__pyx_t_4, __pyx_t_10);
+        #endif
+        ++__pyx_t_10;
+      }
+      if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 609, __pyx_L1_error)
+    } else {
+      __pyx_t_5 = __pyx_t_11(__pyx_t_4);
+      if (unlikely(!__pyx_t_5)) {
+        PyObject* exc_type = PyErr_Occurred();
+        if (exc_type) {
+          if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(2, 609, __pyx_L1_error)
+          PyErr_Clear();
+        }
+        break;
+      }
+    }
+    __Pyx_GOTREF(__pyx_t_5);
+    if (!(likely(PyLong_CheckExact(__pyx_t_5))||((__pyx_t_5) == Py_None) || __Pyx_RaiseUnexpectedTypeError("int", __pyx_t_5))) __PYX_ERR(2, 609, __pyx_L1_error)
+    __Pyx_XDECREF_SET(__pyx_v_i, ((PyObject*)__pyx_t_5));
+    __pyx_t_5 = 0;
+
+    __pyx_t_5 = PyNumber_Power(__pyx_mstate_global->__pyx_int_2, __pyx_v_i, Py_None); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 610, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_flag); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 610, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_t_6 = PyNumber_And(__pyx_t_5, __pyx_t_1); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 610, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(2, 610, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    if (__pyx_t_3) {
+
+      if (unlikely(__pyx_v_flags_lookup_dict == Py_None)) {
+        PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
+        __PYX_ERR(2, 611, __pyx_L1_error)
+      }
+      __pyx_t_6 = PyNumber_Power(__pyx_mstate_global->__pyx_int_2, __pyx_v_i, Py_None); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 611, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      __pyx_t_1 = __Pyx_PyDict_GetItem(__pyx_v_flags_lookup_dict, __pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 611, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+      __pyx_t_12 = __Pyx_PyList_Append(__pyx_v_ret, __pyx_t_1); if (unlikely(__pyx_t_12 == ((int)-1))) __PYX_ERR(2, 611, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+    }
+
+  }
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(__pyx_v_ret);
+  __pyx_r = __pyx_v_ret;
   goto __pyx_L0;
 
 
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_AVGPRICE", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_AddTraceback("talib._ta_lib.__get_flags", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_open);
-  __Pyx_XDECREF((PyObject *)__pyx_v_high);
-  __Pyx_XDECREF((PyObject *)__pyx_v_low);
-  __Pyx_XDECREF((PyObject *)__pyx_v_close);
+  __Pyx_XDECREF(__pyx_v_value_range);
+  __Pyx_XDECREF(__pyx_v_min_int);
+  __Pyx_XDECREF(__pyx_v_max_int);
+  __Pyx_XDECREF(__pyx_v_ret);
+  __Pyx_XDECREF(__pyx_v_i);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -40232,200 +48700,308 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_382stream_AVGPRICE(CYTHON_UNUSED PyObj
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_385stream_BBANDS(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_384stream_BBANDS[] = " BBANDS(real[, timeperiod=?, nbdevup=?, nbdevdn=?, matype=?])\n\n    Bollinger Bands (Overlap Studies)\n\n    Inputs:\n        real: (any ndarray)\n    Parameters:\n        timeperiod: 5\n        nbdevup: 2\n        nbdevdn: 2\n        matype: 0 (Simple Moving Average)\n    Outputs:\n        upperband\n        middleband\n        lowerband\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_385stream_BBANDS = {"stream_BBANDS", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_385stream_BBANDS, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_384stream_BBANDS};
-static PyObject *__pyx_pw_5talib_7_ta_lib_385stream_BBANDS(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_real = 0;
-  int __pyx_v_timeperiod;
-  double __pyx_v_nbdevup;
-  double __pyx_v_nbdevdn;
-  int __pyx_v_matype;
+static PyObject *__pyx_pw_5talib_7_ta_lib_355_ta_getFuncInfo(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_354_ta_getFuncInfo, "_ta_getFuncInfo(char *function_name)\n\nReturns the info dict for the function. It has the following keys: name,\ngroup, help, flags, num_inputs, num_opt_inputs and num_outputs.");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_355_ta_getFuncInfo = {"_ta_getFuncInfo", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_355_ta_getFuncInfo, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_354_ta_getFuncInfo};
+static PyObject *__pyx_pw_5talib_7_ta_lib_355_ta_getFuncInfo(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  char *__pyx_v_function_name;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_BBANDS (wrapper)", 0);
+  __Pyx_RefNannySetupContext("_ta_getFuncInfo (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,&__pyx_n_s_nbdevup,&__pyx_n_s_nbdevdn,&__pyx_n_s_matype,0};
-    PyObject* values[5] = {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  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
-        CYTHON_FALLTHROUGH;
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_function_name,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(2, 648, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 648, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod);
-          if (value) { values[1] = value; kw_args--; }
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_nbdevup);
-          if (value) { values[2] = value; kw_args--; }
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_nbdevdn);
-          if (value) { values[3] = value; kw_args--; }
-        }
-        CYTHON_FALLTHROUGH;
-        case  4:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_matype);
-          if (value) { values[4] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_BBANDS") < 0)) __PYX_ERR(3, 437, __pyx_L3_error)
-      }
-    } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
-        CYTHON_FALLTHROUGH;
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-        break;
-        default: goto __pyx_L5_argtuple_error;
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "_ta_getFuncInfo", 0) < (0)) __PYX_ERR(2, 648, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("_ta_getFuncInfo", 1, 1, 1, i); __PYX_ERR(2, 648, __pyx_L3_error) }
       }
-    }
-    __pyx_v_real = ((PyArrayObject *)values[0]);
-    if (values[1]) {
-      __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 437, __pyx_L3_error)
-    } else {
-      __pyx_v_timeperiod = ((int)-2147483648);
-    }
-    if (values[2]) {
-      __pyx_v_nbdevup = __pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_nbdevup == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 437, __pyx_L3_error)
-    } else {
-      __pyx_v_nbdevup = ((double)-4e37);
-    }
-    if (values[3]) {
-      __pyx_v_nbdevdn = __pyx_PyFloat_AsDouble(values[3]); if (unlikely((__pyx_v_nbdevdn == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 437, __pyx_L3_error)
-    } else {
-      __pyx_v_nbdevdn = ((double)-4e37);
-    }
-    if (values[4]) {
-      __pyx_v_matype = __Pyx_PyInt_As_int(values[4]); if (unlikely((__pyx_v_matype == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 437, __pyx_L3_error)
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
     } else {
-      __pyx_v_matype = ((int)0);
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 648, __pyx_L3_error)
     }
+    __pyx_v_function_name = __Pyx_PyObject_AsWritableString(values[0]); if (unlikely((!__pyx_v_function_name) && PyErr_Occurred())) __PYX_ERR(2, 648, __pyx_L3_error)
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_BBANDS", 0, 1, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 437, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("_ta_getFuncInfo", 1, 1, 1, __pyx_nargs); __PYX_ERR(2, 648, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_BBANDS", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib._ta_getFuncInfo", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 437, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_384stream_BBANDS(__pyx_self, __pyx_v_real, __pyx_v_timeperiod, __pyx_v_nbdevup, __pyx_v_nbdevdn, __pyx_v_matype);
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_354_ta_getFuncInfo(__pyx_self, __pyx_v_function_name);
 
   /* function exit code */
-  goto __pyx_L0;
-  __pyx_L1_error:;
-  __pyx_r = NULL;
-  __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_384stream_BBANDS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod, double __pyx_v_nbdevup, double __pyx_v_nbdevdn, int __pyx_v_matype) {
-  npy_intp __pyx_v_length;
+static PyObject *__pyx_pf_5talib_7_ta_lib_354_ta_getFuncInfo(CYTHON_UNUSED PyObject *__pyx_self, char *__pyx_v_function_name) {
+  TA_FuncInfo const *__pyx_v_info;
   TA_RetCode __pyx_v_retCode;
-  double *__pyx_v_real_data;
-  int __pyx_v_outbegidx;
-  int __pyx_v_outnbelement;
-  double __pyx_v_outrealupperband;
-  double __pyx_v_outrealmiddleband;
-  double __pyx_v_outreallowerband;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
+  TA_FuncHandle const *__pyx_t_1;
   PyObject *__pyx_t_2 = NULL;
   PyObject *__pyx_t_3 = NULL;
   PyObject *__pyx_t_4 = NULL;
-  __Pyx_RefNannySetupContext("stream_BBANDS", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_real);
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  size_t __pyx_t_7;
+  PyObject *__pyx_t_8 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_ta_getFuncInfo", 0);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 463, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib___ta_getFuncHandle(__pyx_v_function_name); if (unlikely(__pyx_t_1 == ((TA_FuncHandle const *)0) && PyErr_Occurred())) __PYX_ERR(2, 654, __pyx_L1_error)
+  __pyx_v_retCode = TA_GetFuncInfo(__pyx_t_1, (&__pyx_v_info));
 
-  __pyx_v_real_data = ((double *)__pyx_v_real->data);
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_GetFuncInfo, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 655, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __Pyx_XDECREF(__pyx_r);
 
-  __pyx_v_outrealupperband = __pyx_v_5talib_7_ta_lib_NaN;
+  __pyx_t_2 = __Pyx_PyDict_NewPresized(7); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 658, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_4 = NULL;
+  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_bytes2str); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 658, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_6 = __Pyx_PyBytes_FromString(__pyx_v_info->name); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 658, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __pyx_t_7 = 1;
+  #if CYTHON_UNPACK_METHODS
+  if (unlikely(PyMethod_Check(__pyx_t_5))) {
+    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
+    assert(__pyx_t_4);
+    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
+    __Pyx_INCREF(__pyx_t_4);
+    __Pyx_INCREF(__pyx__function);
+    __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
+    __pyx_t_7 = 0;
+  }
+  #endif
+  {
+    PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_6};
+    __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 658, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+  }
+  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_name, __pyx_t_3) < (0)) __PYX_ERR(2, 658, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
-  __pyx_v_outrealmiddleband = __pyx_v_5talib_7_ta_lib_NaN;
+  __pyx_t_5 = NULL;
+  __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_bytes2str); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 659, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __pyx_t_4 = __Pyx_PyBytes_FromString(__pyx_v_info->group); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 659, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_7 = 1;
+  #if CYTHON_UNPACK_METHODS
+  if (unlikely(PyMethod_Check(__pyx_t_6))) {
+    __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_6);
+    assert(__pyx_t_5);
+    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6);
+    __Pyx_INCREF(__pyx_t_5);
+    __Pyx_INCREF(__pyx__function);
+    __Pyx_DECREF_SET(__pyx_t_6, __pyx__function);
+    __pyx_t_7 = 0;
+  }
+  #endif
+  {
+    PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_4};
+    __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 659, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+  }
+  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_group, __pyx_t_3) < (0)) __PYX_ERR(2, 658, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
-  __pyx_v_outreallowerband = __pyx_v_5talib_7_ta_lib_NaN;
+  __pyx_t_6 = NULL;
+  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_bytes2str); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 660, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = __Pyx_PyBytes_FromString(__pyx_v_info->hint); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 660, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_7 = 1;
+  #if CYTHON_UNPACK_METHODS
+  if (unlikely(PyMethod_Check(__pyx_t_4))) {
+    __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4);
+    assert(__pyx_t_6);
+    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
+    __Pyx_INCREF(__pyx_t_6);
+    __Pyx_INCREF(__pyx__function);
+    __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
+    __pyx_t_7 = 0;
+  }
+  #endif
+  {
+    PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_5};
+    __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 660, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+  }
+  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_display_name, __pyx_t_3) < (0)) __PYX_ERR(2, 658, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
-  __pyx_v_retCode = TA_BBANDS((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, __pyx_v_nbdevup, __pyx_v_nbdevdn, __pyx_v_matype, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outrealupperband), (&__pyx_v_outrealmiddleband), (&__pyx_v_outreallowerband));
+  __pyx_t_4 = NULL;
+  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_get_flags); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 661, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_6 = __Pyx_PyLong_From_TA_FuncFlags(__pyx_v_info->flags); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 661, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_TA_FUNC_FLAGS); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 661, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_8);
+  __pyx_t_7 = 1;
+  #if CYTHON_UNPACK_METHODS
+  if (unlikely(PyMethod_Check(__pyx_t_5))) {
+    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
+    assert(__pyx_t_4);
+    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5);
+    __Pyx_INCREF(__pyx_t_4);
+    __Pyx_INCREF(__pyx__function);
+    __Pyx_DECREF_SET(__pyx_t_5, __pyx__function);
+    __pyx_t_7 = 0;
+  }
+  #endif
+  {
+    PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_t_6, __pyx_t_8};
+    __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+__pyx_t_7, (3-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 661, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+  }
+  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_function_flags, __pyx_t_3) < (0)) __PYX_ERR(2, 658, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_BBANDS, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 470, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_5 = NULL;
+  __Pyx_INCREF((PyObject *)(&PyLong_Type));
+  __pyx_t_8 = ((PyObject *)(&PyLong_Type)); 
+  __pyx_t_6 = __Pyx_PyLong_From_unsigned_int(__pyx_v_info->nbInput); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 662, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __pyx_t_7 = 1;
+  {
+    PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_6};
+    __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_8, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+    if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 662, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+  }
+  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_num_inputs, __pyx_t_3) < (0)) __PYX_ERR(2, 658, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
-  __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outrealupperband); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 471, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = PyFloat_FromDouble(__pyx_v_outrealmiddleband); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 471, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = PyFloat_FromDouble(__pyx_v_outreallowerband); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 471, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 471, __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_2);
-  PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_2);
-  __Pyx_GIVEREF(__pyx_t_3);
-  PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_t_3);
-  __pyx_t_1 = 0;
+  __pyx_t_8 = NULL;
+  __Pyx_INCREF((PyObject *)(&PyLong_Type));
+  __pyx_t_6 = ((PyObject *)(&PyLong_Type)); 
+  __pyx_t_5 = __Pyx_PyLong_From_unsigned_int(__pyx_v_info->nbOptInput); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 663, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_7 = 1;
+  {
+    PyObject *__pyx_callargs[2] = {__pyx_t_8, __pyx_t_5};
+    __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+    __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 663, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+  }
+  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_num_opt_inputs, __pyx_t_3) < (0)) __PYX_ERR(2, 658, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  __pyx_t_6 = NULL;
+  __Pyx_INCREF((PyObject *)(&PyLong_Type));
+  __pyx_t_5 = ((PyObject *)(&PyLong_Type)); 
+  __pyx_t_8 = __Pyx_PyLong_From_unsigned_int(__pyx_v_info->nbOutput); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 664, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_8);
+  __pyx_t_7 = 1;
+  {
+    PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_8};
+    __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 664, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+  }
+  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_num_outputs, __pyx_t_3) < (0)) __PYX_ERR(2, 658, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_r = __pyx_t_2;
   __pyx_t_2 = 0;
-  __pyx_t_3 = 0;
-  __pyx_r = __pyx_t_4;
-  __pyx_t_4 = 0;
   goto __pyx_L0;
 
 
   /* 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("talib._ta_lib.stream_BBANDS", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_AddTraceback("talib._ta_lib._ta_getFuncInfo", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_real);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -40433,149 +49009,250 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_384stream_BBANDS(CYTHON_UNUSED PyObjec
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_387stream_BETA(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_386stream_BETA[] = " BETA(real0, real1[, timeperiod=?])\n\n    Beta (Statistic Functions)\n\n    Inputs:\n        real0: (any ndarray)\n        real1: (any ndarray)\n    Parameters:\n        timeperiod: 5\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_387stream_BETA = {"stream_BETA", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_387stream_BETA, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_386stream_BETA};
-static PyObject *__pyx_pw_5talib_7_ta_lib_387stream_BETA(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_real0 = 0;
-  PyArrayObject *__pyx_v_real1 = 0;
-  int __pyx_v_timeperiod;
+static PyObject *__pyx_pw_5talib_7_ta_lib_357_ta_getInputParameterInfo(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_356_ta_getInputParameterInfo, "_ta_getInputParameterInfo(char *function_name, int idx)\n\nReturns the function's input info dict for the given index. It has two\nkeys: name and flags.");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_357_ta_getInputParameterInfo = {"_ta_getInputParameterInfo", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_357_ta_getInputParameterInfo, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_356_ta_getInputParameterInfo};
+static PyObject *__pyx_pw_5talib_7_ta_lib_357_ta_getInputParameterInfo(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  char *__pyx_v_function_name;
+  int __pyx_v_idx;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_BETA (wrapper)", 0);
+  __Pyx_RefNannySetupContext("_ta_getInputParameterInfo (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real0,&__pyx_n_s_real1,&__pyx_n_s_timeperiod,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);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_function_name,&__pyx_mstate_global->__pyx_n_u_idx,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(2, 667, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(2, 667, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 667, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real0)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real1)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_BETA", 0, 2, 3, 1); __PYX_ERR(3, 475, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod);
-          if (value) { values[2] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_BETA") < 0)) __PYX_ERR(3, 475, __pyx_L3_error)
-      }
-    } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-        break;
-        default: goto __pyx_L5_argtuple_error;
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "_ta_getInputParameterInfo", 0) < (0)) __PYX_ERR(2, 667, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("_ta_getInputParameterInfo", 1, 2, 2, i); __PYX_ERR(2, 667, __pyx_L3_error) }
       }
-    }
-    __pyx_v_real0 = ((PyArrayObject *)values[0]);
-    __pyx_v_real1 = ((PyArrayObject *)values[1]);
-    if (values[2]) {
-      __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 475, __pyx_L3_error)
+    } else if (unlikely(__pyx_nargs != 2)) {
+      goto __pyx_L5_argtuple_error;
     } else {
-      __pyx_v_timeperiod = ((int)-2147483648);
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 667, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(2, 667, __pyx_L3_error)
     }
+    __pyx_v_function_name = __Pyx_PyObject_AsWritableString(values[0]); if (unlikely((!__pyx_v_function_name) && PyErr_Occurred())) __PYX_ERR(2, 667, __pyx_L3_error)
+    __pyx_v_idx = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_idx == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 667, __pyx_L3_error)
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_BETA", 0, 2, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 475, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("_ta_getInputParameterInfo", 1, 2, 2, __pyx_nargs); __PYX_ERR(2, 667, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_BETA", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib._ta_getInputParameterInfo", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real0), __pyx_ptype_5numpy_ndarray, 0, "real0", 0))) __PYX_ERR(3, 475, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real1), __pyx_ptype_5numpy_ndarray, 0, "real1", 0))) __PYX_ERR(3, 475, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_386stream_BETA(__pyx_self, __pyx_v_real0, __pyx_v_real1, __pyx_v_timeperiod);
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_356_ta_getInputParameterInfo(__pyx_self, __pyx_v_function_name, __pyx_v_idx);
 
   /* function exit code */
-  goto __pyx_L0;
-  __pyx_L1_error:;
-  __pyx_r = NULL;
-  __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_386stream_BETA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real0, PyArrayObject *__pyx_v_real1, int __pyx_v_timeperiod) {
-  npy_intp __pyx_v_length;
+static PyObject *__pyx_pf_5talib_7_ta_lib_356_ta_getInputParameterInfo(CYTHON_UNUSED PyObject *__pyx_self, char *__pyx_v_function_name, int __pyx_v_idx) {
+  TA_InputParameterInfo const *__pyx_v_info;
   TA_RetCode __pyx_v_retCode;
-  double *__pyx_v_real0_data;
-  double *__pyx_v_real1_data;
-  int __pyx_v_outbegidx;
-  int __pyx_v_outnbelement;
-  double __pyx_v_outreal;
+  PyObject *__pyx_v_name = NULL;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
-  npy_intp __pyx_t_2;
-  __Pyx_RefNannySetupContext("stream_BETA", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_real0);
-  __Pyx_INCREF((PyObject *)__pyx_v_real1);
+  TA_FuncHandle const *__pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  size_t __pyx_t_6;
+  Py_ssize_t __pyx_t_7;
+  int __pyx_t_8;
+  PyObject *__pyx_t_9 = NULL;
+  PyObject *__pyx_t_10 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_ta_getInputParameterInfo", 0);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 496, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_real0, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib___ta_getFuncHandle(__pyx_v_function_name); if (unlikely(__pyx_t_1 == ((TA_FuncHandle const *)0) && PyErr_Occurred())) __PYX_ERR(2, 673, __pyx_L1_error)
+  __pyx_v_retCode = TA_GetInputParameterInfo(__pyx_t_1, __pyx_v_idx, (&__pyx_v_info));
 
-  __pyx_v_real0_data = ((double *)__pyx_v_real0->data);
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_GetInputParameterInfo, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 674, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 498, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_real1, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
+  __pyx_t_3 = NULL;
+  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_bytes2str); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 676, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = __Pyx_PyBytes_FromString(__pyx_v_info->paramName); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 676, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_6 = 1;
+  #if CYTHON_UNPACK_METHODS
+  if (unlikely(PyMethod_Check(__pyx_t_4))) {
+    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4);
+    assert(__pyx_t_3);
+    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
+    __Pyx_INCREF(__pyx_t_3);
+    __Pyx_INCREF(__pyx__function);
+    __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
+    __pyx_t_6 = 0;
+  }
+  #endif
+  {
+    PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_t_5};
+    __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 676, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+  }
+  __pyx_v_name = __pyx_t_2;
+  __pyx_t_2 = 0;
 
-  __pyx_v_real1_data = ((double *)__pyx_v_real1->data);
+  __pyx_t_7 = __Pyx_PyUnicode_GET_LENGTH(__pyx_mstate_global->__pyx_n_u_in); if (unlikely(__pyx_t_7 == ((Py_ssize_t)-1))) __PYX_ERR(2, 677, __pyx_L1_error)
+  __pyx_t_5 = __Pyx_PyObject_GetSlice(__pyx_v_name, __pyx_t_7, 0, NULL, NULL, NULL, 1, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 677, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_4 = __pyx_t_5;
+  __Pyx_INCREF(__pyx_t_4);
+  __pyx_t_6 = 0;
+  {
+    PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL};
+    __pyx_t_2 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_lower, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 677, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+  }
+  __Pyx_DECREF_SET(__pyx_v_name, __pyx_t_2);
+  __pyx_t_2 = 0;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_real0, __pyx_v_real1); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(3, 500, __pyx_L1_error)
-  __pyx_v_length = __pyx_t_2;
+  __pyx_t_8 = (__Pyx_PySequence_ContainsTF(__pyx_mstate_global->__pyx_n_u_real, __pyx_v_name, Py_EQ)); if (unlikely((__pyx_t_8 < 0))) __PYX_ERR(2, 678, __pyx_L1_error)
+  if (__pyx_t_8) {
 
-  __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
+    __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_name, __pyx_mstate_global->__pyx_n_u_replace); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 679, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_mstate_global->__pyx_tuple[0], NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 679, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_DECREF_SET(__pyx_v_name, __pyx_t_5);
+    __pyx_t_5 = 0;
 
-  __pyx_v_retCode = TA_BETA((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real0_data, __pyx_v_real1_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
+    goto __pyx_L3;
+  }
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_BETA, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 503, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_8 = (__Pyx_PySequence_ContainsTF(__pyx_mstate_global->__pyx_n_u_price, __pyx_v_name, Py_EQ)); if (unlikely((__pyx_t_8 < 0))) __PYX_ERR(2, 680, __pyx_L1_error)
+  if (__pyx_t_8) {
+
+    __Pyx_INCREF(__pyx_mstate_global->__pyx_n_u_prices);
+    __Pyx_DECREF_SET(__pyx_v_name, __pyx_mstate_global->__pyx_n_u_prices);
+
+  }
+  __pyx_L3:;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 504, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_r = __pyx_t_1;
-  __pyx_t_1 = 0;
+
+  __pyx_t_5 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 684, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_name, __pyx_v_name) < (0)) __PYX_ERR(2, 684, __pyx_L1_error)
+
+  __pyx_t_4 = NULL;
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_get_flags); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 685, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_9 = __Pyx_PyLong_From_TA_InputFlags(__pyx_v_info->flags); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 685, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_9);
+  __Pyx_GetModuleGlobalName(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_TA_INPUT_FLAGS); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 685, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_10);
+  __pyx_t_6 = 1;
+  #if CYTHON_UNPACK_METHODS
+  if (unlikely(PyMethod_Check(__pyx_t_3))) {
+    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
+    assert(__pyx_t_4);
+    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3);
+    __Pyx_INCREF(__pyx_t_4);
+    __Pyx_INCREF(__pyx__function);
+    __Pyx_DECREF_SET(__pyx_t_3, __pyx__function);
+    __pyx_t_6 = 0;
+  }
+  #endif
+  {
+    PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_t_9, __pyx_t_10};
+    __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 685, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+  }
+  if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_price_series, __pyx_t_2) < (0)) __PYX_ERR(2, 684, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_r = __pyx_t_5;
+  __pyx_t_5 = 0;
   goto __pyx_L0;
 
 
   /* function exit code */
   __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_BETA", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_9);
+  __Pyx_XDECREF(__pyx_t_10);
+  __Pyx_AddTraceback("talib._ta_lib._ta_getInputParameterInfo", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_real0);
-  __Pyx_XDECREF((PyObject *)__pyx_v_real1);
+  __Pyx_XDECREF(__pyx_v_name);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -40583,175 +49260,277 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_386stream_BETA(CYTHON_UNUSED PyObject
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_389stream_BOP(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_388stream_BOP[] = " BOP(open, high, low, close)\n\n    Balance Of Power (Momentum Indicators)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_389stream_BOP = {"stream_BOP", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_389stream_BOP, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_388stream_BOP};
-static PyObject *__pyx_pw_5talib_7_ta_lib_389stream_BOP(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_open = 0;
-  PyArrayObject *__pyx_v_high = 0;
-  PyArrayObject *__pyx_v_low = 0;
-  PyArrayObject *__pyx_v_close = 0;
+static PyObject *__pyx_pw_5talib_7_ta_lib_359_ta_getOptInputParameterInfo(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_358_ta_getOptInputParameterInfo, "_ta_getOptInputParameterInfo(char *function_name, int idx)\n\nReturns the function's opt_input info dict for the given index. It has the\nfollowing keys: name, display_name, type, help, default_value and value.");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_359_ta_getOptInputParameterInfo = {"_ta_getOptInputParameterInfo", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_359_ta_getOptInputParameterInfo, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_358_ta_getOptInputParameterInfo};
+static PyObject *__pyx_pw_5talib_7_ta_lib_359_ta_getOptInputParameterInfo(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  char *__pyx_v_function_name;
+  int __pyx_v_idx;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_BOP (wrapper)", 0);
+  __Pyx_RefNannySetupContext("_ta_getOptInputParameterInfo (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_function_name,&__pyx_mstate_global->__pyx_n_u_idx,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(2, 688, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(2, 688, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 688, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_BOP", 1, 4, 4, 1); __PYX_ERR(3, 508, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_BOP", 1, 4, 4, 2); __PYX_ERR(3, 508, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_BOP", 1, 4, 4, 3); __PYX_ERR(3, 508, __pyx_L3_error)
-        }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "_ta_getOptInputParameterInfo", 0) < (0)) __PYX_ERR(2, 688, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("_ta_getOptInputParameterInfo", 1, 2, 2, i); __PYX_ERR(2, 688, __pyx_L3_error) }
       }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_BOP") < 0)) __PYX_ERR(3, 508, __pyx_L3_error)
-      }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
+    } else if (unlikely(__pyx_nargs != 2)) {
       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[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 688, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(2, 688, __pyx_L3_error)
     }
-    __pyx_v_open = ((PyArrayObject *)values[0]);
-    __pyx_v_high = ((PyArrayObject *)values[1]);
-    __pyx_v_low = ((PyArrayObject *)values[2]);
-    __pyx_v_close = ((PyArrayObject *)values[3]);
+    __pyx_v_function_name = __Pyx_PyObject_AsWritableString(values[0]); if (unlikely((!__pyx_v_function_name) && PyErr_Occurred())) __PYX_ERR(2, 688, __pyx_L3_error)
+    __pyx_v_idx = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_idx == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 688, __pyx_L3_error)
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_BOP", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 508, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("_ta_getOptInputParameterInfo", 1, 2, 2, __pyx_nargs); __PYX_ERR(2, 688, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_BOP", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib._ta_getOptInputParameterInfo", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 508, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 508, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 508, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 508, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_388stream_BOP(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_358_ta_getOptInputParameterInfo(__pyx_self, __pyx_v_function_name, __pyx_v_idx);
 
   /* function exit code */
-  goto __pyx_L0;
-  __pyx_L1_error:;
-  __pyx_r = NULL;
-  __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_388stream_BOP(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
-  npy_intp __pyx_v_length;
+static PyObject *__pyx_pf_5talib_7_ta_lib_358_ta_getOptInputParameterInfo(CYTHON_UNUSED PyObject *__pyx_self, char *__pyx_v_function_name, int __pyx_v_idx) {
+  TA_OptInputParameterInfo const *__pyx_v_info;
   TA_RetCode __pyx_v_retCode;
-  double *__pyx_v_open_data;
-  double *__pyx_v_high_data;
-  double *__pyx_v_low_data;
-  double *__pyx_v_close_data;
-  int __pyx_v_outbegidx;
-  int __pyx_v_outnbelement;
-  double __pyx_v_outreal;
+  PyObject *__pyx_v_name = NULL;
+  PyObject *__pyx_v_default_value = NULL;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
-  npy_intp __pyx_t_2;
-  __Pyx_RefNannySetupContext("stream_BOP", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_open);
-  __Pyx_INCREF((PyObject *)__pyx_v_high);
-  __Pyx_INCREF((PyObject *)__pyx_v_low);
-  __Pyx_INCREF((PyObject *)__pyx_v_close);
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 528, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
+  TA_FuncHandle const *__pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  size_t __pyx_t_6;
+  Py_ssize_t __pyx_t_7;
+  int __pyx_t_8;
+  PyObject *__pyx_t_9 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_ta_getOptInputParameterInfo", 0);
 
-  __pyx_v_open_data = ((double *)__pyx_v_open->data);
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib___ta_getFuncHandle(__pyx_v_function_name); if (unlikely(__pyx_t_1 == ((TA_FuncHandle const *)0) && PyErr_Occurred())) __PYX_ERR(2, 694, __pyx_L1_error)
+  __pyx_v_retCode = TA_GetOptInputParameterInfo(__pyx_t_1, __pyx_v_idx, (&__pyx_v_info));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 530, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_GetOptInputParameterInfo, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 695, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_v_high_data = ((double *)__pyx_v_high->data);
+  __pyx_t_3 = NULL;
+  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_bytes2str); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 697, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = __Pyx_PyBytes_FromString(__pyx_v_info->paramName); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 697, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_6 = 1;
+  #if CYTHON_UNPACK_METHODS
+  if (unlikely(PyMethod_Check(__pyx_t_4))) {
+    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4);
+    assert(__pyx_t_3);
+    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
+    __Pyx_INCREF(__pyx_t_3);
+    __Pyx_INCREF(__pyx__function);
+    __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
+    __pyx_t_6 = 0;
+  }
+  #endif
+  {
+    PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_t_5};
+    __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 697, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+  }
+  __pyx_v_name = __pyx_t_2;
+  __pyx_t_2 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 532, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
+  __pyx_t_7 = __Pyx_PyUnicode_GET_LENGTH(__pyx_mstate_global->__pyx_n_u_optIn); if (unlikely(__pyx_t_7 == ((Py_ssize_t)-1))) __PYX_ERR(2, 698, __pyx_L1_error)
+  __pyx_t_5 = __Pyx_PyObject_GetSlice(__pyx_v_name, __pyx_t_7, 0, NULL, NULL, NULL, 1, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 698, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_4 = __pyx_t_5;
+  __Pyx_INCREF(__pyx_t_4);
+  __pyx_t_6 = 0;
+  {
+    PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL};
+    __pyx_t_2 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_lower, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 698, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+  }
+  __Pyx_DECREF_SET(__pyx_v_name, __pyx_t_2);
+  __pyx_t_2 = 0;
 
-  __pyx_v_low_data = ((double *)__pyx_v_low->data);
+  __pyx_t_8 = (__pyx_v_info->type > 1);
+  if (__pyx_t_8) {
+    __pyx_t_5 = PyLong_FromDouble(__pyx_v_info->defaultValue); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 699, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __pyx_t_2 = __pyx_t_5;
+    __pyx_t_5 = 0;
+  } else {
+    __pyx_t_5 = PyFloat_FromDouble(__pyx_v_info->defaultValue); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 699, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __pyx_t_2 = __pyx_t_5;
+    __pyx_t_5 = 0;
+  }
+  __pyx_v_default_value = __pyx_t_2;
+  __pyx_t_2 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 534, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
+  __Pyx_XDECREF(__pyx_r);
 
-  __pyx_v_close_data = ((double *)__pyx_v_close->data);
+  __pyx_t_2 = __Pyx_PyDict_NewPresized(6); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 702, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_name, __pyx_v_name) < (0)) __PYX_ERR(2, 702, __pyx_L1_error)
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(3, 536, __pyx_L1_error)
-  __pyx_v_length = __pyx_t_2;
+  __pyx_t_4 = NULL;
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_bytes2str); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 703, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_9 = __Pyx_PyBytes_FromString(__pyx_v_info->displayName); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 703, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_9);
+  __pyx_t_6 = 1;
+  #if CYTHON_UNPACK_METHODS
+  if (unlikely(PyMethod_Check(__pyx_t_3))) {
+    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
+    assert(__pyx_t_4);
+    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3);
+    __Pyx_INCREF(__pyx_t_4);
+    __Pyx_INCREF(__pyx__function);
+    __Pyx_DECREF_SET(__pyx_t_3, __pyx__function);
+    __pyx_t_6 = 0;
+  }
+  #endif
+  {
+    PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_9};
+    __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 703, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+  }
+  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_display_name, __pyx_t_5) < (0)) __PYX_ERR(2, 702, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
 
-  __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
+  __pyx_t_5 = __Pyx_PyLong_From_TA_OptInputParameterType(__pyx_v_info->type); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 704, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_type_2, __pyx_t_5) < (0)) __PYX_ERR(2, 702, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
 
-  __pyx_v_retCode = TA_BOP((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
+  __pyx_t_3 = NULL;
+  __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_bytes2str); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 705, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_9);
+  __pyx_t_4 = __Pyx_PyBytes_FromString(__pyx_v_info->hint); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 705, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_6 = 1;
+  #if CYTHON_UNPACK_METHODS
+  if (unlikely(PyMethod_Check(__pyx_t_9))) {
+    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_9);
+    assert(__pyx_t_3);
+    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_9);
+    __Pyx_INCREF(__pyx_t_3);
+    __Pyx_INCREF(__pyx__function);
+    __Pyx_DECREF_SET(__pyx_t_9, __pyx__function);
+    __pyx_t_6 = 0;
+  }
+  #endif
+  {
+    PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_t_4};
+    __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_9, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+    if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 705, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+  }
+  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_help, __pyx_t_5) < (0)) __PYX_ERR(2, 702, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_BOP, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 539, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_default_value, __pyx_v_default_value) < (0)) __PYX_ERR(2, 702, __pyx_L1_error)
 
-  __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 540, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_r = __pyx_t_1;
-  __pyx_t_1 = 0;
+  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_value, Py_None) < (0)) __PYX_ERR(2, 702, __pyx_L1_error)
+  __pyx_r = __pyx_t_2;
+  __pyx_t_2 = 0;
   goto __pyx_L0;
 
 
   /* function exit code */
   __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_BOP", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_9);
+  __Pyx_AddTraceback("talib._ta_lib._ta_getOptInputParameterInfo", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_open);
-  __Pyx_XDECREF((PyObject *)__pyx_v_high);
-  __Pyx_XDECREF((PyObject *)__pyx_v_low);
-  __Pyx_XDECREF((PyObject *)__pyx_v_close);
+  __Pyx_XDECREF(__pyx_v_name);
+  __Pyx_XDECREF(__pyx_v_default_value);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -40759,171 +49538,266 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_388stream_BOP(CYTHON_UNUSED PyObject *
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_391stream_CCI(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_390stream_CCI[] = " CCI(high, low, close[, timeperiod=?])\n\n    Commodity Channel Index (Momentum Indicators)\n\n    Inputs:\n        prices: ['high', 'low', 'close']\n    Parameters:\n        timeperiod: 14\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_391stream_CCI = {"stream_CCI", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_391stream_CCI, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_390stream_CCI};
-static PyObject *__pyx_pw_5talib_7_ta_lib_391stream_CCI(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_high = 0;
-  PyArrayObject *__pyx_v_low = 0;
-  PyArrayObject *__pyx_v_close = 0;
-  int __pyx_v_timeperiod;
+static PyObject *__pyx_pw_5talib_7_ta_lib_361_ta_getOutputParameterInfo(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_360_ta_getOutputParameterInfo, "_ta_getOutputParameterInfo(char *function_name, int idx)\n\nReturns the function's output info dict for the given index. It has two\nkeys: name and flags.");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_361_ta_getOutputParameterInfo = {"_ta_getOutputParameterInfo", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_361_ta_getOutputParameterInfo, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_360_ta_getOutputParameterInfo};
+static PyObject *__pyx_pw_5talib_7_ta_lib_361_ta_getOutputParameterInfo(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  char *__pyx_v_function_name;
+  int __pyx_v_idx;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_CCI (wrapper)", 0);
+  __Pyx_RefNannySetupContext("_ta_getOutputParameterInfo (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,&__pyx_n_s_timeperiod,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_function_name,&__pyx_mstate_global->__pyx_n_u_idx,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(2, 710, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(2, 710, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 710, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CCI", 0, 3, 4, 1); __PYX_ERR(3, 544, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CCI", 0, 3, 4, 2); __PYX_ERR(3, 544, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod);
-          if (value) { values[3] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_CCI") < 0)) __PYX_ERR(3, 544, __pyx_L3_error)
-      }
-    } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-        break;
-        default: goto __pyx_L5_argtuple_error;
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "_ta_getOutputParameterInfo", 0) < (0)) __PYX_ERR(2, 710, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("_ta_getOutputParameterInfo", 1, 2, 2, i); __PYX_ERR(2, 710, __pyx_L3_error) }
       }
-    }
-    __pyx_v_high = ((PyArrayObject *)values[0]);
-    __pyx_v_low = ((PyArrayObject *)values[1]);
-    __pyx_v_close = ((PyArrayObject *)values[2]);
-    if (values[3]) {
-      __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[3]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 544, __pyx_L3_error)
+    } else if (unlikely(__pyx_nargs != 2)) {
+      goto __pyx_L5_argtuple_error;
     } else {
-      __pyx_v_timeperiod = ((int)-2147483648);
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 710, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(2, 710, __pyx_L3_error)
     }
+    __pyx_v_function_name = __Pyx_PyObject_AsWritableString(values[0]); if (unlikely((!__pyx_v_function_name) && PyErr_Occurred())) __PYX_ERR(2, 710, __pyx_L3_error)
+    __pyx_v_idx = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_idx == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 710, __pyx_L3_error)
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_CCI", 0, 3, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 544, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("_ta_getOutputParameterInfo", 1, 2, 2, __pyx_nargs); __PYX_ERR(2, 710, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_CCI", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib._ta_getOutputParameterInfo", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 544, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 544, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 544, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_390stream_CCI(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_timeperiod);
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_360_ta_getOutputParameterInfo(__pyx_self, __pyx_v_function_name, __pyx_v_idx);
 
   /* function exit code */
-  goto __pyx_L0;
-  __pyx_L1_error:;
-  __pyx_r = NULL;
-  __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_390stream_CCI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod) {
-  npy_intp __pyx_v_length;
+static PyObject *__pyx_pf_5talib_7_ta_lib_360_ta_getOutputParameterInfo(CYTHON_UNUSED PyObject *__pyx_self, char *__pyx_v_function_name, int __pyx_v_idx) {
+  TA_OutputParameterInfo const *__pyx_v_info;
   TA_RetCode __pyx_v_retCode;
-  double *__pyx_v_high_data;
-  double *__pyx_v_low_data;
-  double *__pyx_v_close_data;
-  int __pyx_v_outbegidx;
-  int __pyx_v_outnbelement;
-  double __pyx_v_outreal;
+  PyObject *__pyx_v_name = NULL;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
-  npy_intp __pyx_t_2;
-  __Pyx_RefNannySetupContext("stream_CCI", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_high);
-  __Pyx_INCREF((PyObject *)__pyx_v_low);
-  __Pyx_INCREF((PyObject *)__pyx_v_close);
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 565, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
+  TA_FuncHandle const *__pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  size_t __pyx_t_6;
+  Py_ssize_t __pyx_t_7;
+  int __pyx_t_8;
+  int __pyx_t_9;
+  int __pyx_t_10;
+  PyObject *__pyx_t_11 = NULL;
+  PyObject *__pyx_t_12 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_ta_getOutputParameterInfo", 0);
 
-  __pyx_v_high_data = ((double *)__pyx_v_high->data);
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib___ta_getFuncHandle(__pyx_v_function_name); if (unlikely(__pyx_t_1 == ((TA_FuncHandle const *)0) && PyErr_Occurred())) __PYX_ERR(2, 716, __pyx_L1_error)
+  __pyx_v_retCode = TA_GetOutputParameterInfo(__pyx_t_1, __pyx_v_idx, (&__pyx_v_info));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 567, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_GetOutputParameterInfo, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 717, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_v_low_data = ((double *)__pyx_v_low->data);
+  __pyx_t_3 = NULL;
+  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_bytes2str); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 719, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = __Pyx_PyBytes_FromString(__pyx_v_info->paramName); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 719, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_6 = 1;
+  #if CYTHON_UNPACK_METHODS
+  if (unlikely(PyMethod_Check(__pyx_t_4))) {
+    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4);
+    assert(__pyx_t_3);
+    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4);
+    __Pyx_INCREF(__pyx_t_3);
+    __Pyx_INCREF(__pyx__function);
+    __Pyx_DECREF_SET(__pyx_t_4, __pyx__function);
+    __pyx_t_6 = 0;
+  }
+  #endif
+  {
+    PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_t_5};
+    __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 719, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+  }
+  __pyx_v_name = __pyx_t_2;
+  __pyx_t_2 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 569, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
+  __pyx_t_7 = __Pyx_PyUnicode_GET_LENGTH(__pyx_mstate_global->__pyx_n_u_out); if (unlikely(__pyx_t_7 == ((Py_ssize_t)-1))) __PYX_ERR(2, 720, __pyx_L1_error)
+  __pyx_t_5 = __Pyx_PyObject_GetSlice(__pyx_v_name, __pyx_t_7, 0, NULL, NULL, NULL, 1, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 720, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_4 = __pyx_t_5;
+  __Pyx_INCREF(__pyx_t_4);
+  __pyx_t_6 = 0;
+  {
+    PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL};
+    __pyx_t_2 = __Pyx_PyObject_FastCallMethod(__pyx_mstate_global->__pyx_n_u_lower, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 720, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+  }
+  __Pyx_DECREF_SET(__pyx_v_name, __pyx_t_2);
+  __pyx_t_2 = 0;
 
-  __pyx_v_close_data = ((double *)__pyx_v_close->data);
+  __pyx_t_9 = (__Pyx_PySequence_ContainsTF(__pyx_mstate_global->__pyx_n_u_real, __pyx_v_name, Py_EQ)); if (unlikely((__pyx_t_9 < 0))) __PYX_ERR(2, 722, __pyx_L1_error)
+  if (__pyx_t_9) {
+  } else {
+    __pyx_t_8 = __pyx_t_9;
+    goto __pyx_L4_bool_binop_done;
+  }
+  __Pyx_INCREF(__pyx_v_name);
+  __pyx_t_2 = __pyx_v_name;
+  __pyx_t_10 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_real, Py_NE)); if (unlikely((__pyx_t_10 < 0))) __PYX_ERR(2, 722, __pyx_L1_error)
+  if (__pyx_t_10) {
+  } else {
+    __pyx_t_9 = __pyx_t_10;
+    goto __pyx_L6_bool_binop_done;
+  }
+  __pyx_t_10 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_real0, Py_NE)); if (unlikely((__pyx_t_10 < 0))) __PYX_ERR(2, 722, __pyx_L1_error)
+  if (__pyx_t_10) {
+  } else {
+    __pyx_t_9 = __pyx_t_10;
+    goto __pyx_L6_bool_binop_done;
+  }
+  __pyx_t_10 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_real1, Py_NE)); if (unlikely((__pyx_t_10 < 0))) __PYX_ERR(2, 722, __pyx_L1_error)
+  __pyx_t_9 = __pyx_t_10;
+  __pyx_L6_bool_binop_done:;
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_10 = __pyx_t_9;
+  __pyx_t_8 = __pyx_t_10;
+  __pyx_L4_bool_binop_done:;
+  if (__pyx_t_8) {
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(3, 571, __pyx_L1_error)
-  __pyx_v_length = __pyx_t_2;
+    __pyx_t_7 = __Pyx_PyUnicode_GET_LENGTH(__pyx_mstate_global->__pyx_n_u_real); if (unlikely(__pyx_t_7 == ((Py_ssize_t)-1))) __PYX_ERR(2, 723, __pyx_L1_error)
+    __pyx_t_2 = __Pyx_PyObject_GetSlice(__pyx_v_name, __pyx_t_7, 0, NULL, NULL, NULL, 1, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 723, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF_SET(__pyx_v_name, __pyx_t_2);
+    __pyx_t_2 = 0;
 
-  __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
+  }
 
-  __pyx_v_retCode = TA_CCI((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
+  __Pyx_XDECREF(__pyx_r);
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CCI, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 574, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 726, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_name, __pyx_v_name) < (0)) __PYX_ERR(2, 726, __pyx_L1_error)
 
-  __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 575, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_r = __pyx_t_1;
-  __pyx_t_1 = 0;
+  __pyx_t_4 = NULL;
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_get_flags); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 727, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_11 = __Pyx_PyLong_From_TA_OutputFlags(__pyx_v_info->flags); if (unlikely(!__pyx_t_11)) __PYX_ERR(2, 727, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_11);
+  __Pyx_GetModuleGlobalName(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_TA_OUTPUT_FLAGS); if (unlikely(!__pyx_t_12)) __PYX_ERR(2, 727, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_12);
+  __pyx_t_6 = 1;
+  #if CYTHON_UNPACK_METHODS
+  if (unlikely(PyMethod_Check(__pyx_t_3))) {
+    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
+    assert(__pyx_t_4);
+    PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3);
+    __Pyx_INCREF(__pyx_t_4);
+    __Pyx_INCREF(__pyx__function);
+    __Pyx_DECREF_SET(__pyx_t_3, __pyx__function);
+    __pyx_t_6 = 0;
+  }
+  #endif
+  {
+    PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_t_11, __pyx_t_12};
+    __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+    __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 727, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+  }
+  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_flags, __pyx_t_5) < (0)) __PYX_ERR(2, 726, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_r = __pyx_t_2;
+  __pyx_t_2 = 0;
   goto __pyx_L0;
 
 
   /* function exit code */
   __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_CCI", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __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);
+  __Pyx_XDECREF(__pyx_t_12);
+  __Pyx_AddTraceback("talib._ta_lib._ta_getOutputParameterInfo", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_high);
-  __Pyx_XDECREF((PyObject *)__pyx_v_low);
-  __Pyx_XDECREF((PyObject *)__pyx_v_close);
+  __Pyx_XDECREF(__pyx_v_name);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -40931,524 +49805,935 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_390stream_CCI(CYTHON_UNUSED PyObject *
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_393stream_CDL2CROWS(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_392stream_CDL2CROWS[] = " CDL2CROWS(open, high, low, close)\n\n    Two Crows (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_393stream_CDL2CROWS = {"stream_CDL2CROWS", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_393stream_CDL2CROWS, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_392stream_CDL2CROWS};
-static PyObject *__pyx_pw_5talib_7_ta_lib_393stream_CDL2CROWS(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_open = 0;
-  PyArrayObject *__pyx_v_high = 0;
-  PyArrayObject *__pyx_v_low = 0;
-  PyArrayObject *__pyx_v_close = 0;
+static PyObject *__pyx_pw_5talib_7_ta_lib_363_get_defaults_and_docs(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_362_get_defaults_and_docs, "_get_defaults_and_docs(func_info)\n\nReturns a tuple with two outputs: defaults, a dict of parameter defaults,\nand documentation, a formatted docstring for the function.\n.. Note: func_info should come from Function.info, *not* _ta_getFuncInfo.");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_363_get_defaults_and_docs = {"_get_defaults_and_docs", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_363_get_defaults_and_docs, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_362_get_defaults_and_docs};
+static PyObject *__pyx_pw_5talib_7_ta_lib_363_get_defaults_and_docs(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyObject *__pyx_v_func_info = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_CDL2CROWS (wrapper)", 0);
+  __Pyx_RefNannySetupContext("_get_defaults_and_docs (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_func_info,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(2, 730, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 730, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDL2CROWS", 1, 4, 4, 1); __PYX_ERR(3, 579, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDL2CROWS", 1, 4, 4, 2); __PYX_ERR(3, 579, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDL2CROWS", 1, 4, 4, 3); __PYX_ERR(3, 579, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_CDL2CROWS") < 0)) __PYX_ERR(3, 579, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "_get_defaults_and_docs", 0) < (0)) __PYX_ERR(2, 730, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("_get_defaults_and_docs", 1, 1, 1, i); __PYX_ERR(2, 730, __pyx_L3_error) }
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
+    } else if (unlikely(__pyx_nargs != 1)) {
       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[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 730, __pyx_L3_error)
     }
-    __pyx_v_open = ((PyArrayObject *)values[0]);
-    __pyx_v_high = ((PyArrayObject *)values[1]);
-    __pyx_v_low = ((PyArrayObject *)values[2]);
-    __pyx_v_close = ((PyArrayObject *)values[3]);
+    __pyx_v_func_info = values[0];
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_CDL2CROWS", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 579, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("_get_defaults_and_docs", 1, 1, 1, __pyx_nargs); __PYX_ERR(2, 730, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDL2CROWS", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib._get_defaults_and_docs", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 579, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 579, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 579, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 579, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_392stream_CDL2CROWS(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_362_get_defaults_and_docs(__pyx_self, __pyx_v_func_info);
 
   /* function exit code */
-  goto __pyx_L0;
-  __pyx_L1_error:;
-  __pyx_r = NULL;
-  __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_392stream_CDL2CROWS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
-  npy_intp __pyx_v_length;
-  TA_RetCode __pyx_v_retCode;
-  double *__pyx_v_open_data;
-  double *__pyx_v_high_data;
-  double *__pyx_v_low_data;
-  double *__pyx_v_close_data;
-  int __pyx_v_outbegidx;
-  int __pyx_v_outnbelement;
-  int __pyx_v_outinteger;
+static PyObject *__pyx_pf_5talib_7_ta_lib_362_get_defaults_and_docs(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_func_info) {
+  PyObject *__pyx_v_defaults = NULL;
+  PyObject *__pyx_v_func_line = NULL;
+  PyObject *__pyx_v_func_args = NULL;
+  PyObject *__pyx_v_docs = NULL;
+  PyObject *__pyx_v_input_names = NULL;
+  PyObject *__pyx_v_input_name = NULL;
+  PyObject *__pyx_v_value = NULL;
+  PyObject *__pyx_v_params = NULL;
+  PyObject *__pyx_v_param = NULL;
+  PyObject *__pyx_v_outputs = NULL;
+  PyObject *__pyx_v_output = NULL;
+  PyObject *__pyx_v_documentation = NULL;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  npy_intp __pyx_t_2;
-  __Pyx_RefNannySetupContext("stream_CDL2CROWS", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_open);
-  __Pyx_INCREF((PyObject *)__pyx_v_high);
-  __Pyx_INCREF((PyObject *)__pyx_v_low);
-  __Pyx_INCREF((PyObject *)__pyx_v_close);
+  PyObject *__pyx_t_2 = NULL;
+  int __pyx_t_3;
+  Py_ssize_t __pyx_t_4;
+  PyObject *(*__pyx_t_5)(PyObject *);
+  int __pyx_t_6;
+  int __pyx_t_7;
+  PyObject *__pyx_t_8 = NULL;
+  PyObject *__pyx_t_9[4];
+  PyObject *__pyx_t_10 = NULL;
+  PyObject *__pyx_t_11[5];
+  PyObject *__pyx_t_12 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_get_defaults_and_docs", 0);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 599, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 736, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
+  __pyx_v_defaults = ((PyObject*)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  __pyx_v_open_data = ((double *)__pyx_v_open->data);
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 601, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyObject_Dict_GetItem(__pyx_v_func_info, __pyx_mstate_global->__pyx_n_u_name); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 737, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_2 = PyList_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 737, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_GIVEREF(__pyx_t_1);
+  if (__Pyx_PyList_SET_ITEM(__pyx_t_2, 0, __pyx_t_1) != (0)) __PYX_ERR(2, 737, __pyx_L1_error);
+  __Pyx_INCREF(__pyx_mstate_global->__pyx_kp_u__6);
+  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_kp_u__6);
+  if (__Pyx_PyList_SET_ITEM(__pyx_t_2, 1, __pyx_mstate_global->__pyx_kp_u__6) != (0)) __PYX_ERR(2, 737, __pyx_L1_error);
   __pyx_t_1 = 0;
+  __pyx_v_func_line = ((PyObject*)__pyx_t_2);
+  __pyx_t_2 = 0;
 
-  __pyx_v_high_data = ((double *)__pyx_v_high->data);
+  __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 738, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_INCREF(__pyx_mstate_global->__pyx_kp_u_input_arrays_2);
+  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_kp_u_input_arrays_2);
+  if (__Pyx_PyList_SET_ITEM(__pyx_t_2, 0, __pyx_mstate_global->__pyx_kp_u_input_arrays_2) != (0)) __PYX_ERR(2, 738, __pyx_L1_error);
+  __pyx_v_func_args = ((PyObject*)__pyx_t_2);
+  __pyx_t_2 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 603, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
+  __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 739, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_v_docs = ((PyObject*)__pyx_t_2);
+  __pyx_t_2 = 0;
 
-  __pyx_v_low_data = ((double *)__pyx_v_low->data);
+  __pyx_t_2 = __Pyx_PyUnicode_FormatSafe(__pyx_mstate_global->__pyx_kp_u_display_name_s_group_s, __pyx_v_func_info); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 740, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = __Pyx_PyList_Append(__pyx_v_docs, __pyx_t_2); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(2, 740, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 605, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyObject_Dict_GetItem(__pyx_v_func_info, __pyx_mstate_global->__pyx_n_u_input_names); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 742, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_v_input_names = __pyx_t_2;
+  __pyx_t_2 = 0;
 
-  __pyx_v_close_data = ((double *)__pyx_v_close->data);
+  __pyx_t_3 = __Pyx_PyList_Append(__pyx_v_docs, __pyx_mstate_global->__pyx_kp_u_Inputs); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(2, 743, __pyx_L1_error)
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(3, 607, __pyx_L1_error)
-  __pyx_v_length = __pyx_t_2;
+  if (likely(PyList_CheckExact(__pyx_v_input_names)) || PyTuple_CheckExact(__pyx_v_input_names)) {
+    __pyx_t_2 = __pyx_v_input_names; __Pyx_INCREF(__pyx_t_2);
+    __pyx_t_4 = 0;
+    __pyx_t_5 = NULL;
+  } else {
+    __pyx_t_4 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_v_input_names); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 744, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_t_5 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 744, __pyx_L1_error)
+  }
+  for (;;) {
+    if (likely(!__pyx_t_5)) {
+      if (likely(PyList_CheckExact(__pyx_t_2))) {
+        {
+          Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_2);
+          #if !CYTHON_ASSUME_SAFE_SIZE
+          if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 744, __pyx_L1_error)
+          #endif
+          if (__pyx_t_4 >= __pyx_temp) break;
+        }
+        __pyx_t_1 = __Pyx_PyList_GetItemRef(__pyx_t_2, __pyx_t_4);
+        ++__pyx_t_4;
+      } else {
+        {
+          Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_2);
+          #if !CYTHON_ASSUME_SAFE_SIZE
+          if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 744, __pyx_L1_error)
+          #endif
+          if (__pyx_t_4 >= __pyx_temp) break;
+        }
+        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+        __pyx_t_1 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_4));
+        #else
+        __pyx_t_1 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_4);
+        #endif
+        ++__pyx_t_4;
+      }
+      if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 744, __pyx_L1_error)
+    } else {
+      __pyx_t_1 = __pyx_t_5(__pyx_t_2);
+      if (unlikely(!__pyx_t_1)) {
+        PyObject* exc_type = PyErr_Occurred();
+        if (exc_type) {
+          if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(2, 744, __pyx_L1_error)
+          PyErr_Clear();
+        }
+        break;
+      }
+    }
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_XDECREF_SET(__pyx_v_input_name, __pyx_t_1);
+    __pyx_t_1 = 0;
 
-  __pyx_v_outinteger = 0;
+    __pyx_t_1 = __Pyx_PyObject_GetItem(__pyx_v_input_names, __pyx_v_input_name); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 745, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_XDECREF_SET(__pyx_v_value, __pyx_t_1);
+    __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_CDL2CROWS((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
+    __pyx_t_6 = PyList_Check(__pyx_v_value); 
+    __pyx_t_7 = (!__pyx_t_6);
+    if (__pyx_t_7) {
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDL2CROWS, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 610, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+      __Pyx_INCREF(__pyx_mstate_global->__pyx_kp_u_any_ndarray);
+      __Pyx_DECREF_SET(__pyx_v_value, __pyx_mstate_global->__pyx_kp_u_any_ndarray);
 
-  __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 611, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_r = __pyx_t_1;
-  __pyx_t_1 = 0;
-  goto __pyx_L0;
+    }
 
+    __pyx_t_1 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Str(__pyx_v_input_name), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 748, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_t_8 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Str(__pyx_v_value), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 748, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_8);
+    __pyx_t_9[0] = __pyx_mstate_global->__pyx_kp_u__7;
+    __pyx_t_9[1] = __pyx_t_1;
+    __pyx_t_9[2] = __pyx_mstate_global->__pyx_kp_u_;
+    __pyx_t_9[3] = __pyx_t_8;
+    __pyx_t_10 = __Pyx_PyUnicode_Join(__pyx_t_9, 4, 4 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_1) + 2 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_8), 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_1) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8));
+    if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 748, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_10);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+    __pyx_t_3 = __Pyx_PyList_Append(__pyx_v_docs, __pyx_t_10); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(2, 748, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
 
-  /* function exit code */
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDL2CROWS", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = NULL;
-  __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_open);
-  __Pyx_XDECREF((PyObject *)__pyx_v_high);
-  __Pyx_XDECREF((PyObject *)__pyx_v_low);
-  __Pyx_XDECREF((PyObject *)__pyx_v_close);
-  __Pyx_XGIVEREF(__pyx_r);
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
+  }
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
+  __pyx_t_2 = __Pyx_PyObject_Dict_GetItem(__pyx_v_func_info, __pyx_mstate_global->__pyx_n_u_parameters); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 750, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_v_params = __pyx_t_2;
+  __pyx_t_2 = 0;
 
-/* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_395stream_CDL3BLACKCROWS(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_394stream_CDL3BLACKCROWS[] = " CDL3BLACKCROWS(open, high, low, close)\n\n    Three Black Crows (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_395stream_CDL3BLACKCROWS = {"stream_CDL3BLACKCROWS", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_395stream_CDL3BLACKCROWS, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_394stream_CDL3BLACKCROWS};
-static PyObject *__pyx_pw_5talib_7_ta_lib_395stream_CDL3BLACKCROWS(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_open = 0;
-  PyArrayObject *__pyx_v_high = 0;
-  PyArrayObject *__pyx_v_low = 0;
-  PyArrayObject *__pyx_v_close = 0;
-  PyObject *__pyx_r = 0;
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_CDL3BLACKCROWS (wrapper)", 0);
-  {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-        CYTHON_FALLTHROUGH;
-        case  0: break;
-        default: goto __pyx_L5_argtuple_error;
-      }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDL3BLACKCROWS", 1, 4, 4, 1); __PYX_ERR(3, 615, __pyx_L3_error)
+  __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_v_params); if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(2, 751, __pyx_L1_error)
+  if (__pyx_t_7) {
+
+    __pyx_t_3 = __Pyx_PyList_Append(__pyx_v_docs, __pyx_mstate_global->__pyx_kp_u_Parameters); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(2, 752, __pyx_L1_error)
+
+  }
+
+  if (likely(PyList_CheckExact(__pyx_v_params)) || PyTuple_CheckExact(__pyx_v_params)) {
+    __pyx_t_2 = __pyx_v_params; __Pyx_INCREF(__pyx_t_2);
+    __pyx_t_4 = 0;
+    __pyx_t_5 = NULL;
+  } else {
+    __pyx_t_4 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_v_params); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 753, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_t_5 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 753, __pyx_L1_error)
+  }
+  for (;;) {
+    if (likely(!__pyx_t_5)) {
+      if (likely(PyList_CheckExact(__pyx_t_2))) {
+        {
+          Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_2);
+          #if !CYTHON_ASSUME_SAFE_SIZE
+          if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 753, __pyx_L1_error)
+          #endif
+          if (__pyx_t_4 >= __pyx_temp) break;
         }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDL3BLACKCROWS", 1, 4, 4, 2); __PYX_ERR(3, 615, __pyx_L3_error)
+        __pyx_t_10 = __Pyx_PyList_GetItemRef(__pyx_t_2, __pyx_t_4);
+        ++__pyx_t_4;
+      } else {
+        {
+          Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_2);
+          #if !CYTHON_ASSUME_SAFE_SIZE
+          if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 753, __pyx_L1_error)
+          #endif
+          if (__pyx_t_4 >= __pyx_temp) break;
         }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDL3BLACKCROWS", 1, 4, 4, 3); __PYX_ERR(3, 615, __pyx_L3_error)
+        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+        __pyx_t_10 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_4));
+        #else
+        __pyx_t_10 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_4);
+        #endif
+        ++__pyx_t_4;
+      }
+      if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 753, __pyx_L1_error)
+    } else {
+      __pyx_t_10 = __pyx_t_5(__pyx_t_2);
+      if (unlikely(!__pyx_t_10)) {
+        PyObject* exc_type = PyErr_Occurred();
+        if (exc_type) {
+          if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(2, 753, __pyx_L1_error)
+          PyErr_Clear();
         }
+        break;
       }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_CDL3BLACKCROWS") < 0)) __PYX_ERR(3, 615, __pyx_L3_error)
+    }
+    __Pyx_GOTREF(__pyx_t_10);
+    __Pyx_XDECREF_SET(__pyx_v_param, __pyx_t_10);
+    __pyx_t_10 = 0;
+
+    __pyx_t_10 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Str(__pyx_v_param), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 754, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_10);
+    __pyx_t_8 = __Pyx_PyObject_GetItem(__pyx_v_params, __pyx_v_param); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 754, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_8);
+    __pyx_t_1 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Str(__pyx_t_8), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 754, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+    __pyx_t_9[0] = __pyx_mstate_global->__pyx_kp_u__7;
+    __pyx_t_9[1] = __pyx_t_10;
+    __pyx_t_9[2] = __pyx_mstate_global->__pyx_kp_u_;
+    __pyx_t_9[3] = __pyx_t_1;
+    __pyx_t_8 = __Pyx_PyUnicode_Join(__pyx_t_9, 4, 4 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_10) + 2 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_1), 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_10) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_1));
+    if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 754, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_8);
+    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __pyx_t_3 = __Pyx_PyList_Append(__pyx_v_docs, __pyx_t_8); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(2, 754, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+
+    __pyx_t_8 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Str(__pyx_v_param), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 755, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_8);
+    __pyx_t_1 = __Pyx_PyObject_GetItem(__pyx_v_params, __pyx_v_param); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 755, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_t_10 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Str(__pyx_t_1), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 755, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_10);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __pyx_t_11[0] = __pyx_mstate_global->__pyx_kp_u__8;
+    __pyx_t_11[1] = __pyx_t_8;
+    __pyx_t_11[2] = __pyx_mstate_global->__pyx_kp_u__9;
+    __pyx_t_11[3] = __pyx_t_10;
+    __pyx_t_11[4] = __pyx_mstate_global->__pyx_kp_u__10;
+    __pyx_t_1 = __Pyx_PyUnicode_Join(__pyx_t_11, 5, 1 * 3 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_8) + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_10), 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_10));
+    if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 755, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+    __pyx_t_3 = __Pyx_PyList_Append(__pyx_v_func_args, __pyx_t_1); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(2, 755, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+    __pyx_t_1 = __Pyx_PyObject_GetItem(__pyx_v_params, __pyx_v_param); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 756, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    if (unlikely((PyDict_SetItem(__pyx_v_defaults, __pyx_v_param, __pyx_t_1) < 0))) __PYX_ERR(2, 756, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+    __pyx_t_7 = (__Pyx_PyUnicode_Equals(__pyx_v_param, __pyx_mstate_global->__pyx_n_u_matype, Py_EQ)); if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(2, 757, __pyx_L1_error)
+    if (__pyx_t_7) {
+
+      __pyx_t_1 = __Pyx_GetItemInt_List(__pyx_v_docs, -1L, long, 1, __Pyx_PyLong_From_long, 1, 1, 1, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 758, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_GetModuleGlobalName(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_MA_Type); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 758, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_10);
+      __pyx_t_8 = __Pyx_PyObject_GetItem(__pyx_v_params, __pyx_v_param); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 758, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_8);
+      __pyx_t_12 = __Pyx_PyObject_GetItem(__pyx_t_10, __pyx_t_8); if (unlikely(!__pyx_t_12)) __PYX_ERR(2, 758, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_12);
+      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+      __pyx_t_8 = __Pyx_PyUnicode_FormatSafe(__pyx_mstate_global->__pyx_kp_u_s_3, __pyx_t_12); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 758, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_8);
+      __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
+      __pyx_t_12 = PyList_New(2); if (unlikely(!__pyx_t_12)) __PYX_ERR(2, 758, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_12);
+      __Pyx_GIVEREF(__pyx_t_1);
+      if (__Pyx_PyList_SET_ITEM(__pyx_t_12, 0, __pyx_t_1) != (0)) __PYX_ERR(2, 758, __pyx_L1_error);
+      __Pyx_GIVEREF(__pyx_t_8);
+      if (__Pyx_PyList_SET_ITEM(__pyx_t_12, 1, __pyx_t_8) != (0)) __PYX_ERR(2, 758, __pyx_L1_error);
+      __pyx_t_1 = 0;
+      __pyx_t_8 = 0;
+      __pyx_t_8 = PyUnicode_Join(__pyx_mstate_global->__pyx_kp_u__11, __pyx_t_12); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 758, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_8);
+      __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
+      if (unlikely((__Pyx_SetItemInt(__pyx_v_docs, -1L, __pyx_t_8, long, 1, __Pyx_PyLong_From_long, 1, 1, 1, 1) < 0))) __PYX_ERR(2, 758, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+
+    }
+
+  }
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  __pyx_t_2 = __Pyx_PyObject_Dict_GetItem(__pyx_v_func_info, __pyx_mstate_global->__pyx_n_u_output_names); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 760, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_v_outputs = __pyx_t_2;
+  __pyx_t_2 = 0;
+
+  __pyx_t_3 = __Pyx_PyList_Append(__pyx_v_docs, __pyx_mstate_global->__pyx_kp_u_Outputs); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(2, 761, __pyx_L1_error)
+
+  if (likely(PyList_CheckExact(__pyx_v_outputs)) || PyTuple_CheckExact(__pyx_v_outputs)) {
+    __pyx_t_2 = __pyx_v_outputs; __Pyx_INCREF(__pyx_t_2);
+    __pyx_t_4 = 0;
+    __pyx_t_5 = NULL;
+  } else {
+    __pyx_t_4 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_v_outputs); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 762, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_t_5 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 762, __pyx_L1_error)
+  }
+  for (;;) {
+    if (likely(!__pyx_t_5)) {
+      if (likely(PyList_CheckExact(__pyx_t_2))) {
+        {
+          Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_2);
+          #if !CYTHON_ASSUME_SAFE_SIZE
+          if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 762, __pyx_L1_error)
+          #endif
+          if (__pyx_t_4 >= __pyx_temp) break;
+        }
+        __pyx_t_8 = __Pyx_PyList_GetItemRef(__pyx_t_2, __pyx_t_4);
+        ++__pyx_t_4;
+      } else {
+        {
+          Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_2);
+          #if !CYTHON_ASSUME_SAFE_SIZE
+          if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 762, __pyx_L1_error)
+          #endif
+          if (__pyx_t_4 >= __pyx_temp) break;
+        }
+        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+        __pyx_t_8 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_4));
+        #else
+        __pyx_t_8 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_4);
+        #endif
+        ++__pyx_t_4;
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
-      goto __pyx_L5_argtuple_error;
+      if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 762, __pyx_L1_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);
+      __pyx_t_8 = __pyx_t_5(__pyx_t_2);
+      if (unlikely(!__pyx_t_8)) {
+        PyObject* exc_type = PyErr_Occurred();
+        if (exc_type) {
+          if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(2, 762, __pyx_L1_error)
+          PyErr_Clear();
+        }
+        break;
+      }
     }
-    __pyx_v_open = ((PyArrayObject *)values[0]);
-    __pyx_v_high = ((PyArrayObject *)values[1]);
-    __pyx_v_low = ((PyArrayObject *)values[2]);
-    __pyx_v_close = ((PyArrayObject *)values[3]);
+    __Pyx_GOTREF(__pyx_t_8);
+    __Pyx_XDECREF_SET(__pyx_v_output, __pyx_t_8);
+    __pyx_t_8 = 0;
+
+    __pyx_t_7 = (__Pyx_PyUnicode_Equals(__pyx_v_output, __pyx_mstate_global->__pyx_n_u_integer, Py_EQ)); if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(2, 763, __pyx_L1_error)
+    if (__pyx_t_7) {
+
+      __Pyx_INCREF(__pyx_mstate_global->__pyx_kp_u_integer_values_are_100_0_or_100);
+      __Pyx_DECREF_SET(__pyx_v_output, __pyx_mstate_global->__pyx_kp_u_integer_values_are_100_0_or_100);
+
+    }
+
+    __pyx_t_8 = __Pyx_PyUnicode_FormatSafe(__pyx_mstate_global->__pyx_kp_u_s_4, __pyx_v_output); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 765, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_8);
+    __pyx_t_3 = __Pyx_PyList_Append(__pyx_v_docs, __pyx_t_8); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(2, 765, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+
   }
-  goto __pyx_L4_argument_unpacking_done;
-  __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_CDL3BLACKCROWS", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 615, __pyx_L3_error)
-  __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDL3BLACKCROWS", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __Pyx_RefNannyFinishContext();
-  return NULL;
-  __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 615, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 615, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 615, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 615, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_394stream_CDL3BLACKCROWS(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  /* function exit code */
+  __pyx_t_2 = PyUnicode_Join(__pyx_mstate_global->__pyx_kp_u__3, __pyx_v_func_args); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 767, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = __Pyx_PyList_Append(__pyx_v_func_line, __pyx_t_2); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(2, 767, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  __pyx_t_3 = __Pyx_PyList_Append(__pyx_v_func_line, __pyx_mstate_global->__pyx_kp_u__12); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(2, 768, __pyx_L1_error)
+
+  __pyx_t_2 = PyUnicode_Join(__pyx_mstate_global->__pyx_kp_u__2, __pyx_v_func_line); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 769, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = PyList_Insert(__pyx_v_docs, 0, __pyx_t_2); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(2, 769, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  __pyx_t_2 = PyUnicode_Join(__pyx_mstate_global->__pyx_kp_u__13, __pyx_v_docs); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 770, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_v_documentation = ((PyObject*)__pyx_t_2);
+  __pyx_t_2 = 0;
+
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 771, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_INCREF(__pyx_v_defaults);
+  __Pyx_GIVEREF(__pyx_v_defaults);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_defaults) != (0)) __PYX_ERR(2, 771, __pyx_L1_error);
+  __Pyx_INCREF(__pyx_v_documentation);
+  __Pyx_GIVEREF(__pyx_v_documentation);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_v_documentation) != (0)) __PYX_ERR(2, 771, __pyx_L1_error);
+  __pyx_r = __pyx_t_2;
+  __pyx_t_2 = 0;
   goto __pyx_L0;
+
+
+  /* function exit code */
   __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_XDECREF(__pyx_t_10);
+  __Pyx_XDECREF(__pyx_t_12);
+  __Pyx_AddTraceback("talib._ta_lib._get_defaults_and_docs", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_defaults);
+  __Pyx_XDECREF(__pyx_v_func_line);
+  __Pyx_XDECREF(__pyx_v_func_args);
+  __Pyx_XDECREF(__pyx_v_docs);
+  __Pyx_XDECREF(__pyx_v_input_names);
+  __Pyx_XDECREF(__pyx_v_input_name);
+  __Pyx_XDECREF(__pyx_v_value);
+  __Pyx_XDECREF(__pyx_v_params);
+  __Pyx_XDECREF(__pyx_v_param);
+  __Pyx_XDECREF(__pyx_v_outputs);
+  __Pyx_XDECREF(__pyx_v_output);
+  __Pyx_XDECREF(__pyx_v_documentation);
+  __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_394stream_CDL3BLACKCROWS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
-  npy_intp __pyx_v_length;
-  TA_RetCode __pyx_v_retCode;
-  double *__pyx_v_open_data;
-  double *__pyx_v_high_data;
-  double *__pyx_v_low_data;
-  double *__pyx_v_close_data;
-  int __pyx_v_outbegidx;
-  int __pyx_v_outnbelement;
-  int __pyx_v_outinteger;
-  PyObject *__pyx_r = NULL;
+
+static TA_FuncHandle const *__pyx_f_5talib_7_ta_lib___ta_getFuncHandle(char *__pyx_v_function_name) {
+  TA_FuncHandle const *__pyx_v_handle;
+  TA_FuncHandle const *__pyx_r;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  npy_intp __pyx_t_2;
-  __Pyx_RefNannySetupContext("stream_CDL3BLACKCROWS", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_open);
-  __Pyx_INCREF((PyObject *)__pyx_v_high);
-  __Pyx_INCREF((PyObject *)__pyx_v_low);
-  __Pyx_INCREF((PyObject *)__pyx_v_close);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__ta_getFuncHandle", 0);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 635, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_GetFuncHandle, TA_GetFuncHandle(__pyx_v_function_name, (&__pyx_v_handle)), 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 787, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  __pyx_r = __pyx_v_handle;
+  goto __pyx_L0;
 
-  __pyx_v_open_data = ((double *)__pyx_v_open->data);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 637, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("talib._ta_lib.__ta_getFuncHandle", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+
+static TA_ParamHolder *__pyx_f_5talib_7_ta_lib___ta_paramHolderAlloc(char *__pyx_v_function_name) {
+  TA_ParamHolder *__pyx_v_holder;
+  TA_RetCode __pyx_v_retCode;
+  TA_ParamHolder *__pyx_r;
+  __Pyx_RefNannyDeclarations
+  TA_FuncHandle const *__pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__ta_paramHolderAlloc", 0);
+
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib___ta_getFuncHandle(__pyx_v_function_name); if (unlikely(__pyx_t_1 == ((TA_FuncHandle const *)0) && PyErr_Occurred())) __PYX_ERR(2, 795, __pyx_L1_error)
+  __pyx_v_retCode = TA_ParamHolderAlloc(__pyx_t_1, (&__pyx_v_holder));
+
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_ParamHolderAlloc, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 796, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  __pyx_r = __pyx_v_holder;
+  goto __pyx_L0;
+
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("talib._ta_lib.__ta_paramHolderAlloc", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
 
-  __pyx_v_high_data = ((double *)__pyx_v_high->data);
+static int __pyx_f_5talib_7_ta_lib___ta_paramHolderFree(TA_ParamHolder *__pyx_v_params) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__ta_paramHolderFree", 0);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 639, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_ParamHolderFree, TA_ParamHolderFree(__pyx_v_params), 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 804, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+
+  /* function exit code */
+  __pyx_r = 0;
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("talib._ta_lib.__ta_paramHolderFree", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+
+static int __pyx_f_5talib_7_ta_lib___ta_setOptInputParamInteger(TA_ParamHolder *__pyx_v_holder, int __pyx_v_idx, int __pyx_v_value) {
+  TA_RetCode __pyx_v_retCode;
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__ta_setOptInputParamInteger", 0);
 
-  __pyx_v_low_data = ((double *)__pyx_v_low->data);
+  __pyx_v_retCode = TA_SetOptInputParamInteger(__pyx_v_holder, __pyx_v_idx, __pyx_v_value);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 641, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_SetOptInputParamInteger, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 808, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
-  __pyx_v_close_data = ((double *)__pyx_v_close->data);
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(3, 643, __pyx_L1_error)
-  __pyx_v_length = __pyx_t_2;
+  /* function exit code */
+  __pyx_r = 0;
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("talib._ta_lib.__ta_setOptInputParamInteger", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
 
-  __pyx_v_outinteger = 0;
 
-  __pyx_v_retCode = TA_CDL3BLACKCROWS((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
+static int __pyx_f_5talib_7_ta_lib___ta_setOptInputParamReal(TA_ParamHolder *__pyx_v_holder, int __pyx_v_idx, double __pyx_v_value) {
+  TA_RetCode __pyx_v_retCode;
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__ta_setOptInputParamReal", 0);
+
+  __pyx_v_retCode = TA_SetOptInputParamReal(__pyx_v_holder, __pyx_v_idx, __pyx_v_value);
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDL3BLACKCROWS, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 646, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_SetOptInputParamReal, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 812, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
-  __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 647, __pyx_L1_error)
+
+  /* function exit code */
+  __pyx_r = 0;
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("talib._ta_lib.__ta_setOptInputParamReal", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+
+static int __pyx_f_5talib_7_ta_lib___ta_getLookback(TA_ParamHolder *__pyx_v_holder) {
+  int __pyx_v_lookback;
+  TA_RetCode __pyx_v_retCode;
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__ta_getLookback", 0);
+
+  __pyx_v_retCode = TA_GetLookback(__pyx_v_holder, (&__pyx_v_lookback));
+
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_GetLookback, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 817, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_r = __pyx_t_1;
-  __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  __pyx_r = __pyx_v_lookback;
   goto __pyx_L0;
 
 
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDL3BLACKCROWS", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = NULL;
+  __Pyx_AddTraceback("talib._ta_lib.__ta_getLookback", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_open);
-  __Pyx_XDECREF((PyObject *)__pyx_v_high);
-  __Pyx_XDECREF((PyObject *)__pyx_v_low);
-  __Pyx_XDECREF((PyObject *)__pyx_v_close);
-  __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_397stream_CDL3INSIDE(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_396stream_CDL3INSIDE[] = " CDL3INSIDE(open, high, low, close)\n\n    Three Inside Up/Down (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_397stream_CDL3INSIDE = {"stream_CDL3INSIDE", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_397stream_CDL3INSIDE, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_396stream_CDL3INSIDE};
-static PyObject *__pyx_pw_5talib_7_ta_lib_397stream_CDL3INSIDE(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_open = 0;
+static PyObject *__pyx_pw_5talib_7_ta_lib_365stream_ACCBANDS(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_364stream_ACCBANDS, "stream_ACCBANDS(ndarray high, ndarray low, ndarray close, int timeperiod=-0x80000000)\n\nACCBANDS(high, low, close[, timeperiod=?])\n\nAcceleration Bands (Overlap Studies)\n\nInputs:\n    prices: ['high', 'low', 'close']\nParameters:\n    timeperiod: 20\nOutputs:\n    upperband\n    middleband\n    lowerband");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_365stream_ACCBANDS = {"stream_ACCBANDS", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_365stream_ACCBANDS, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_364stream_ACCBANDS};
+static PyObject *__pyx_pw_5talib_7_ta_lib_365stream_ACCBANDS(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
+  int __pyx_v_timeperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_CDL3INSIDE (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_ACCBANDS (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,&__pyx_mstate_global->__pyx_n_u_timeperiod,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 9, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 9, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 9, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 9, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 9, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDL3INSIDE", 1, 4, 4, 1); __PYX_ERR(3, 651, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDL3INSIDE", 1, 4, 4, 2); __PYX_ERR(3, 651, __pyx_L3_error)
-        }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_ACCBANDS", 0) < (0)) __PYX_ERR(5, 9, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 3; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_ACCBANDS", 0, 3, 4, i); __PYX_ERR(5, 9, __pyx_L3_error) }
+      }
+    } else {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 9, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDL3INSIDE", 1, 4, 4, 3); __PYX_ERR(3, 651, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_CDL3INSIDE") < 0)) __PYX_ERR(3, 651, __pyx_L3_error)
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 9, __pyx_L3_error)
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 9, __pyx_L3_error)
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 9, __pyx_L3_error)
+        break;
+        default: goto __pyx_L5_argtuple_error;
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
-      goto __pyx_L5_argtuple_error;
+    }
+    __pyx_v_high = ((PyArrayObject *)values[0]);
+    __pyx_v_low = ((PyArrayObject *)values[1]);
+    __pyx_v_close = ((PyArrayObject *)values[2]);
+    if (values[3]) {
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[3]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 11, __pyx_L3_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);
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
     }
-    __pyx_v_open = ((PyArrayObject *)values[0]);
-    __pyx_v_high = ((PyArrayObject *)values[1]);
-    __pyx_v_low = ((PyArrayObject *)values[2]);
-    __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_CDL3INSIDE", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 651, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_ACCBANDS", 0, 3, 4, __pyx_nargs); __PYX_ERR(5, 9, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDL3INSIDE", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_ACCBANDS", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 651, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 651, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 651, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 651, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_396stream_CDL3INSIDE(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 11, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 11, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 11, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_364stream_ACCBANDS(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_timeperiod);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_396stream_CDL3INSIDE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_364stream_ACCBANDS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
-  double *__pyx_v_open_data;
   double *__pyx_v_high_data;
   double *__pyx_v_low_data;
   double *__pyx_v_close_data;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  int __pyx_v_outinteger;
+  double __pyx_v_outrealupperband;
+  double __pyx_v_outrealmiddleband;
+  double __pyx_v_outreallowerband;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
-  __Pyx_RefNannySetupContext("stream_CDL3INSIDE", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_open);
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_ACCBANDS", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 671, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_v_open_data = ((double *)__pyx_v_open->data);
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 673, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 36, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_high_data = ((double *)__pyx_v_high->data);
+  __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 675, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 38, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_low_data = ((double *)__pyx_v_low->data);
+  __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 677, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 40, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_close_data = ((double *)__pyx_v_close->data);
+  __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close));
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(3, 679, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 42, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
-  __pyx_v_outinteger = 0;
+  __pyx_v_outrealupperband = __pyx_v_5talib_7_ta_lib_NaN;
 
-  __pyx_v_retCode = TA_CDL3INSIDE((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
+  __pyx_v_outrealmiddleband = __pyx_v_5talib_7_ta_lib_NaN;
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDL3INSIDE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 682, __pyx_L1_error)
+  __pyx_v_outreallowerband = __pyx_v_5talib_7_ta_lib_NaN;
+
+  __pyx_v_retCode = TA_ACCBANDS((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outrealupperband), (&__pyx_v_outrealmiddleband), (&__pyx_v_outreallowerband));
+
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_ACCBANDS, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 47, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 683, __pyx_L1_error)
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outrealupperband); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 48, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_r = __pyx_t_1;
+  __pyx_t_3 = PyFloat_FromDouble(__pyx_v_outrealmiddleband); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 48, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = PyFloat_FromDouble(__pyx_v_outreallowerband); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 48, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(5, 48, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_GIVEREF(__pyx_t_1);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1) != (0)) __PYX_ERR(5, 48, __pyx_L1_error);
+  __Pyx_GIVEREF(__pyx_t_3);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_3) != (0)) __PYX_ERR(5, 48, __pyx_L1_error);
+  __Pyx_GIVEREF(__pyx_t_4);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_t_4) != (0)) __PYX_ERR(5, 48, __pyx_L1_error);
   __pyx_t_1 = 0;
+  __pyx_t_3 = 0;
+  __pyx_t_4 = 0;
+  __pyx_r = __pyx_t_5;
+  __pyx_t_5 = 0;
   goto __pyx_L0;
 
 
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDL3INSIDE", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_AddTraceback("talib._ta_lib.stream_ACCBANDS", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_open);
   __Pyx_XDECREF((PyObject *)__pyx_v_high);
   __Pyx_XDECREF((PyObject *)__pyx_v_low);
   __Pyx_XDECREF((PyObject *)__pyx_v_close);
@@ -41459,159 +50744,136 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_396stream_CDL3INSIDE(CYTHON_UNUSED PyO
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_399stream_CDL3LINESTRIKE(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_398stream_CDL3LINESTRIKE[] = " CDL3LINESTRIKE(open, high, low, close)\n\n    Three-Line Strike  (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_399stream_CDL3LINESTRIKE = {"stream_CDL3LINESTRIKE", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_399stream_CDL3LINESTRIKE, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_398stream_CDL3LINESTRIKE};
-static PyObject *__pyx_pw_5talib_7_ta_lib_399stream_CDL3LINESTRIKE(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_open = 0;
-  PyArrayObject *__pyx_v_high = 0;
-  PyArrayObject *__pyx_v_low = 0;
-  PyArrayObject *__pyx_v_close = 0;
+static PyObject *__pyx_pw_5talib_7_ta_lib_367stream_ACOS(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_366stream_ACOS, "stream_ACOS(ndarray real)\n\nACOS(real)\n\nVector Trigonometric ACos (Math Transform)\n\nInputs:\n    real: (any ndarray)\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_367stream_ACOS = {"stream_ACOS", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_367stream_ACOS, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_366stream_ACOS};
+static PyObject *__pyx_pw_5talib_7_ta_lib_367stream_ACOS(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_real = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_CDL3LINESTRIKE (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_ACOS (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 50, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 50, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDL3LINESTRIKE", 1, 4, 4, 1); __PYX_ERR(3, 687, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDL3LINESTRIKE", 1, 4, 4, 2); __PYX_ERR(3, 687, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDL3LINESTRIKE", 1, 4, 4, 3); __PYX_ERR(3, 687, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_CDL3LINESTRIKE") < 0)) __PYX_ERR(3, 687, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_ACOS", 0) < (0)) __PYX_ERR(5, 50, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_ACOS", 1, 1, 1, i); __PYX_ERR(5, 50, __pyx_L3_error) }
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
+    } else if (unlikely(__pyx_nargs != 1)) {
       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[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 50, __pyx_L3_error)
     }
-    __pyx_v_open = ((PyArrayObject *)values[0]);
-    __pyx_v_high = ((PyArrayObject *)values[1]);
-    __pyx_v_low = ((PyArrayObject *)values[2]);
-    __pyx_v_close = ((PyArrayObject *)values[3]);
+    __pyx_v_real = ((PyArrayObject *)values[0]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_CDL3LINESTRIKE", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 687, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_ACOS", 1, 1, 1, __pyx_nargs); __PYX_ERR(5, 50, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDL3LINESTRIKE", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_ACOS", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 687, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 687, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 687, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 687, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_398stream_CDL3LINESTRIKE(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 52, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_366stream_ACOS(__pyx_self, __pyx_v_real);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_398stream_CDL3LINESTRIKE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_366stream_ACOS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
-  double *__pyx_v_open_data;
-  double *__pyx_v_high_data;
-  double *__pyx_v_low_data;
-  double *__pyx_v_close_data;
+  double *__pyx_v_real_data;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  int __pyx_v_outinteger;
+  double __pyx_v_outreal;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  npy_intp __pyx_t_2;
-  __Pyx_RefNannySetupContext("stream_CDL3LINESTRIKE", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_open);
-  __Pyx_INCREF((PyObject *)__pyx_v_high);
-  __Pyx_INCREF((PyObject *)__pyx_v_low);
-  __Pyx_INCREF((PyObject *)__pyx_v_close);
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 707, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_v_open_data = ((double *)__pyx_v_open->data);
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 709, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_v_high_data = ((double *)__pyx_v_high->data);
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 711, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_v_low_data = ((double *)__pyx_v_low->data);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_ACOS", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 713, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 69, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_close_data = ((double *)__pyx_v_close->data);
+  __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real));
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(3, 715, __pyx_L1_error)
-  __pyx_v_length = __pyx_t_2;
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
-  __pyx_v_outinteger = 0;
+  __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
 
-  __pyx_v_retCode = TA_CDL3LINESTRIKE((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
+  __pyx_v_retCode = TA_ACOS((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDL3LINESTRIKE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 718, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_ACOS, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 74, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 719, __pyx_L1_error)
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 75, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -41621,13 +50883,10 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_398stream_CDL3LINESTRIKE(CYTHON_UNUSED
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDL3LINESTRIKE", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_ACOS", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_open);
-  __Pyx_XDECREF((PyObject *)__pyx_v_high);
-  __Pyx_XDECREF((PyObject *)__pyx_v_low);
-  __Pyx_XDECREF((PyObject *)__pyx_v_close);
+  __Pyx_XDECREF((PyObject *)__pyx_v_real);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -41635,159 +50894,192 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_398stream_CDL3LINESTRIKE(CYTHON_UNUSED
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_401stream_CDL3OUTSIDE(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_400stream_CDL3OUTSIDE[] = " CDL3OUTSIDE(open, high, low, close)\n\n    Three Outside Up/Down (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_401stream_CDL3OUTSIDE = {"stream_CDL3OUTSIDE", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_401stream_CDL3OUTSIDE, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_400stream_CDL3OUTSIDE};
-static PyObject *__pyx_pw_5talib_7_ta_lib_401stream_CDL3OUTSIDE(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_open = 0;
+static PyObject *__pyx_pw_5talib_7_ta_lib_369stream_AD(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_368stream_AD, "stream_AD(ndarray high, ndarray low, ndarray close, ndarray volume)\n\nAD(high, low, close, volume)\n\nChaikin A/D Line (Volume Indicators)\n\nInputs:\n    prices: ['high', 'low', 'close', 'volume']\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_369stream_AD = {"stream_AD", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_369stream_AD, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_368stream_AD};
+static PyObject *__pyx_pw_5talib_7_ta_lib_369stream_AD(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
+  PyArrayObject *__pyx_v_volume = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_CDL3OUTSIDE (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_AD (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,&__pyx_mstate_global->__pyx_n_u_volume,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 77, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 77, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 77, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 77, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 77, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDL3OUTSIDE", 1, 4, 4, 1); __PYX_ERR(3, 723, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDL3OUTSIDE", 1, 4, 4, 2); __PYX_ERR(3, 723, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDL3OUTSIDE", 1, 4, 4, 3); __PYX_ERR(3, 723, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_CDL3OUTSIDE") < 0)) __PYX_ERR(3, 723, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_AD", 0) < (0)) __PYX_ERR(5, 77, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_AD", 1, 4, 4, i); __PYX_ERR(5, 77, __pyx_L3_error) }
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
+    } else if (unlikely(__pyx_nargs != 4)) {
       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[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 77, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 77, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 77, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 77, __pyx_L3_error)
     }
-    __pyx_v_open = ((PyArrayObject *)values[0]);
-    __pyx_v_high = ((PyArrayObject *)values[1]);
-    __pyx_v_low = ((PyArrayObject *)values[2]);
-    __pyx_v_close = ((PyArrayObject *)values[3]);
+    __pyx_v_high = ((PyArrayObject *)values[0]);
+    __pyx_v_low = ((PyArrayObject *)values[1]);
+    __pyx_v_close = ((PyArrayObject *)values[2]);
+    __pyx_v_volume = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_CDL3OUTSIDE", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 723, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_AD", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 77, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDL3OUTSIDE", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_AD", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 723, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 723, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 723, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 723, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_400stream_CDL3OUTSIDE(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 79, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 79, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 79, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_volume), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "volume", 0))) __PYX_ERR(5, 79, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_368stream_AD(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_volume);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_400stream_CDL3OUTSIDE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_368stream_AD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, PyArrayObject *__pyx_v_volume) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
-  double *__pyx_v_open_data;
   double *__pyx_v_high_data;
   double *__pyx_v_low_data;
   double *__pyx_v_close_data;
+  double *__pyx_v_volume_data;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  int __pyx_v_outinteger;
+  double __pyx_v_outreal;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
-  __Pyx_RefNannySetupContext("stream_CDL3OUTSIDE", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_open);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_AD", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
+  __Pyx_INCREF((PyObject *)__pyx_v_volume);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 743, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 99, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_open_data = ((double *)__pyx_v_open->data);
+  __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 745, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 101, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_high_data = ((double *)__pyx_v_high->data);
+  __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 747, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 103, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_low_data = ((double *)__pyx_v_low->data);
+  __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 749, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_volume)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 105, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_volume, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_close_data = ((double *)__pyx_v_close->data);
+  __pyx_v_volume_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_volume));
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(3, 751, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_volume); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 107, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
-  __pyx_v_outinteger = 0;
+  __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
 
-  __pyx_v_retCode = TA_CDL3OUTSIDE((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
+  __pyx_v_retCode = TA_AD((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, __pyx_v_volume_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDL3OUTSIDE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 754, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_AD, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 110, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 755, __pyx_L1_error)
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 111, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -41797,13 +51089,13 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_400stream_CDL3OUTSIDE(CYTHON_UNUSED Py
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDL3OUTSIDE", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_AD", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_open);
   __Pyx_XDECREF((PyObject *)__pyx_v_high);
   __Pyx_XDECREF((PyObject *)__pyx_v_low);
   __Pyx_XDECREF((PyObject *)__pyx_v_close);
+  __Pyx_XDECREF((PyObject *)__pyx_v_volume);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -41811,159 +51103,156 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_400stream_CDL3OUTSIDE(CYTHON_UNUSED Py
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_403stream_CDL3STARSINSOUTH(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_402stream_CDL3STARSINSOUTH[] = " CDL3STARSINSOUTH(open, high, low, close)\n\n    Three Stars In The South (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_403stream_CDL3STARSINSOUTH = {"stream_CDL3STARSINSOUTH", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_403stream_CDL3STARSINSOUTH, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_402stream_CDL3STARSINSOUTH};
-static PyObject *__pyx_pw_5talib_7_ta_lib_403stream_CDL3STARSINSOUTH(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_open = 0;
-  PyArrayObject *__pyx_v_high = 0;
-  PyArrayObject *__pyx_v_low = 0;
-  PyArrayObject *__pyx_v_close = 0;
+static PyObject *__pyx_pw_5talib_7_ta_lib_371stream_ADD(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_370stream_ADD, "stream_ADD(ndarray real0, ndarray real1)\n\nADD(real0, real1)\n\nVector Arithmetic Add (Math Operators)\n\nInputs:\n    real0: (any ndarray)\n    real1: (any ndarray)\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_371stream_ADD = {"stream_ADD", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_371stream_ADD, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_370stream_ADD};
+static PyObject *__pyx_pw_5talib_7_ta_lib_371stream_ADD(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_real0 = 0;
+  PyArrayObject *__pyx_v_real1 = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_CDL3STARSINSOUTH (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_ADD (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real0,&__pyx_mstate_global->__pyx_n_u_real1,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 113, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 113, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 113, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDL3STARSINSOUTH", 1, 4, 4, 1); __PYX_ERR(3, 759, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDL3STARSINSOUTH", 1, 4, 4, 2); __PYX_ERR(3, 759, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDL3STARSINSOUTH", 1, 4, 4, 3); __PYX_ERR(3, 759, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_CDL3STARSINSOUTH") < 0)) __PYX_ERR(3, 759, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_ADD", 0) < (0)) __PYX_ERR(5, 113, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_ADD", 1, 2, 2, i); __PYX_ERR(5, 113, __pyx_L3_error) }
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
+    } else if (unlikely(__pyx_nargs != 2)) {
       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[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 113, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 113, __pyx_L3_error)
     }
-    __pyx_v_open = ((PyArrayObject *)values[0]);
-    __pyx_v_high = ((PyArrayObject *)values[1]);
-    __pyx_v_low = ((PyArrayObject *)values[2]);
-    __pyx_v_close = ((PyArrayObject *)values[3]);
+    __pyx_v_real0 = ((PyArrayObject *)values[0]);
+    __pyx_v_real1 = ((PyArrayObject *)values[1]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_CDL3STARSINSOUTH", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 759, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_ADD", 1, 2, 2, __pyx_nargs); __PYX_ERR(5, 113, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDL3STARSINSOUTH", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_ADD", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 759, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 759, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 759, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 759, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_402stream_CDL3STARSINSOUTH(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real0), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real0", 0))) __PYX_ERR(5, 115, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real1), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real1", 0))) __PYX_ERR(5, 115, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_370stream_ADD(__pyx_self, __pyx_v_real0, __pyx_v_real1);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_402stream_CDL3STARSINSOUTH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_370stream_ADD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real0, PyArrayObject *__pyx_v_real1) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
-  double *__pyx_v_open_data;
-  double *__pyx_v_high_data;
-  double *__pyx_v_low_data;
-  double *__pyx_v_close_data;
+  double *__pyx_v_real0_data;
+  double *__pyx_v_real1_data;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  int __pyx_v_outinteger;
+  double __pyx_v_outreal;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
-  __Pyx_RefNannySetupContext("stream_CDL3STARSINSOUTH", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_open);
-  __Pyx_INCREF((PyObject *)__pyx_v_high);
-  __Pyx_INCREF((PyObject *)__pyx_v_low);
-  __Pyx_INCREF((PyObject *)__pyx_v_close);
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 779, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_v_open_data = ((double *)__pyx_v_open->data);
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 781, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_v_high_data = ((double *)__pyx_v_high->data);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_ADD", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_real0);
+  __Pyx_INCREF((PyObject *)__pyx_v_real1);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 783, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 134, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_real0, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_low_data = ((double *)__pyx_v_low->data);
+  __pyx_v_real0_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real0));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 785, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 136, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_real1, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_close_data = ((double *)__pyx_v_close->data);
+  __pyx_v_real1_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real1));
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(3, 787, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_real0, __pyx_v_real1); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 138, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
-  __pyx_v_outinteger = 0;
+  __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
 
-  __pyx_v_retCode = TA_CDL3STARSINSOUTH((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
+  __pyx_v_retCode = TA_ADD((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real0_data, __pyx_v_real1_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDL3STARSINSOUTH, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 790, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_ADD, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 141, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 791, __pyx_L1_error)
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 142, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -41973,13 +51262,11 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_402stream_CDL3STARSINSOUTH(CYTHON_UNUS
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDL3STARSINSOUTH", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_ADD", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_open);
-  __Pyx_XDECREF((PyObject *)__pyx_v_high);
-  __Pyx_XDECREF((PyObject *)__pyx_v_low);
-  __Pyx_XDECREF((PyObject *)__pyx_v_close);
+  __Pyx_XDECREF((PyObject *)__pyx_v_real0);
+  __Pyx_XDECREF((PyObject *)__pyx_v_real1);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -41987,159 +51274,223 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_402stream_CDL3STARSINSOUTH(CYTHON_UNUS
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_405stream_CDL3WHITESOLDIERS(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_404stream_CDL3WHITESOLDIERS[] = " CDL3WHITESOLDIERS(open, high, low, close)\n\n    Three Advancing White Soldiers (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_405stream_CDL3WHITESOLDIERS = {"stream_CDL3WHITESOLDIERS", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_405stream_CDL3WHITESOLDIERS, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_404stream_CDL3WHITESOLDIERS};
-static PyObject *__pyx_pw_5talib_7_ta_lib_405stream_CDL3WHITESOLDIERS(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_open = 0;
+static PyObject *__pyx_pw_5talib_7_ta_lib_373stream_ADOSC(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_372stream_ADOSC, "stream_ADOSC(ndarray high, ndarray low, ndarray close, ndarray volume, int fastperiod=-0x80000000, int slowperiod=-0x80000000)\n\nADOSC(high, low, close, volume[, fastperiod=?, slowperiod=?])\n\nChaikin A/D Oscillator (Volume Indicators)\n\nInputs:\n    prices: ['high', 'low', 'close', 'volume']\nParameters:\n    fastperiod: 3\n    slowperiod: 10\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_373stream_ADOSC = {"stream_ADOSC", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_373stream_ADOSC, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_372stream_ADOSC};
+static PyObject *__pyx_pw_5talib_7_ta_lib_373stream_ADOSC(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
+  PyArrayObject *__pyx_v_volume = 0;
+  int __pyx_v_fastperiod;
+  int __pyx_v_slowperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[6] = {0,0,0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_CDL3WHITESOLDIERS (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_ADOSC (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,&__pyx_mstate_global->__pyx_n_u_volume,&__pyx_mstate_global->__pyx_n_u_fastperiod,&__pyx_mstate_global->__pyx_n_u_slowperiod,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 144, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  6:
+        values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(5, 144, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  5:
+        values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(5, 144, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 144, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 144, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 144, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 144, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDL3WHITESOLDIERS", 1, 4, 4, 1); __PYX_ERR(3, 795, __pyx_L3_error)
-        }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_ADOSC", 0) < (0)) __PYX_ERR(5, 144, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_ADOSC", 0, 4, 6, i); __PYX_ERR(5, 144, __pyx_L3_error) }
+      }
+    } else {
+      switch (__pyx_nargs) {
+        case  6:
+        values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(5, 144, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDL3WHITESOLDIERS", 1, 4, 4, 2); __PYX_ERR(3, 795, __pyx_L3_error)
-        }
+        case  5:
+        values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(5, 144, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDL3WHITESOLDIERS", 1, 4, 4, 3); __PYX_ERR(3, 795, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_CDL3WHITESOLDIERS") < 0)) __PYX_ERR(3, 795, __pyx_L3_error)
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 144, __pyx_L3_error)
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 144, __pyx_L3_error)
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 144, __pyx_L3_error)
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 144, __pyx_L3_error)
+        break;
+        default: goto __pyx_L5_argtuple_error;
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
-      goto __pyx_L5_argtuple_error;
+    }
+    __pyx_v_high = ((PyArrayObject *)values[0]);
+    __pyx_v_low = ((PyArrayObject *)values[1]);
+    __pyx_v_close = ((PyArrayObject *)values[2]);
+    __pyx_v_volume = ((PyArrayObject *)values[3]);
+    if (values[4]) {
+      __pyx_v_fastperiod = __Pyx_PyLong_As_int(values[4]); if (unlikely((__pyx_v_fastperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 146, __pyx_L3_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);
+      __pyx_v_fastperiod = ((int)((int)-2147483648));
+    }
+    if (values[5]) {
+      __pyx_v_slowperiod = __Pyx_PyLong_As_int(values[5]); if (unlikely((__pyx_v_slowperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 146, __pyx_L3_error)
+    } else {
+      __pyx_v_slowperiod = ((int)((int)-2147483648));
     }
-    __pyx_v_open = ((PyArrayObject *)values[0]);
-    __pyx_v_high = ((PyArrayObject *)values[1]);
-    __pyx_v_low = ((PyArrayObject *)values[2]);
-    __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_CDL3WHITESOLDIERS", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 795, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_ADOSC", 0, 4, 6, __pyx_nargs); __PYX_ERR(5, 144, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDL3WHITESOLDIERS", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_ADOSC", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 795, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 795, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 795, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 795, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_404stream_CDL3WHITESOLDIERS(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 146, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 146, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 146, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_volume), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "volume", 0))) __PYX_ERR(5, 146, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_372stream_ADOSC(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_volume, __pyx_v_fastperiod, __pyx_v_slowperiod);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_404stream_CDL3WHITESOLDIERS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_372stream_ADOSC(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, PyArrayObject *__pyx_v_volume, int __pyx_v_fastperiod, int __pyx_v_slowperiod) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
-  double *__pyx_v_open_data;
   double *__pyx_v_high_data;
   double *__pyx_v_low_data;
   double *__pyx_v_close_data;
+  double *__pyx_v_volume_data;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  int __pyx_v_outinteger;
+  double __pyx_v_outreal;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
-  __Pyx_RefNannySetupContext("stream_CDL3WHITESOLDIERS", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_open);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_ADOSC", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
+  __Pyx_INCREF((PyObject *)__pyx_v_volume);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 815, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 169, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_open_data = ((double *)__pyx_v_open->data);
+  __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 817, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 171, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_high_data = ((double *)__pyx_v_high->data);
+  __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 819, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 173, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_low_data = ((double *)__pyx_v_low->data);
+  __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 821, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_volume)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 175, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_volume, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_close_data = ((double *)__pyx_v_close->data);
+  __pyx_v_volume_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_volume));
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(3, 823, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_volume); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 177, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
-  __pyx_v_outinteger = 0;
+  __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
 
-  __pyx_v_retCode = TA_CDL3WHITESOLDIERS((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
+  __pyx_v_retCode = TA_ADOSC((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, __pyx_v_volume_data, __pyx_v_fastperiod, __pyx_v_slowperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDL3WHITESOLDIERS, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 826, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_ADOSC, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 180, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 827, __pyx_L1_error)
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 181, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -42149,13 +51500,13 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_404stream_CDL3WHITESOLDIERS(CYTHON_UNU
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDL3WHITESOLDIERS", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_ADOSC", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_open);
   __Pyx_XDECREF((PyObject *)__pyx_v_high);
   __Pyx_XDECREF((PyObject *)__pyx_v_low);
   __Pyx_XDECREF((PyObject *)__pyx_v_close);
+  __Pyx_XDECREF((PyObject *)__pyx_v_volume);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -42163,177 +51514,191 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_404stream_CDL3WHITESOLDIERS(CYTHON_UNU
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_407stream_CDLABANDONEDBABY(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_406stream_CDLABANDONEDBABY[] = " CDLABANDONEDBABY(open, high, low, close[, penetration=?])\n\n    Abandoned Baby (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Parameters:\n        penetration: 0.3\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_407stream_CDLABANDONEDBABY = {"stream_CDLABANDONEDBABY", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_407stream_CDLABANDONEDBABY, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_406stream_CDLABANDONEDBABY};
-static PyObject *__pyx_pw_5talib_7_ta_lib_407stream_CDLABANDONEDBABY(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_open = 0;
+static PyObject *__pyx_pw_5talib_7_ta_lib_375stream_ADX(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_374stream_ADX, "stream_ADX(ndarray high, ndarray low, ndarray close, int timeperiod=-0x80000000)\n\nADX(high, low, close[, timeperiod=?])\n\nAverage Directional Movement Index (Momentum Indicators)\n\nInputs:\n    prices: ['high', 'low', 'close']\nParameters:\n    timeperiod: 14\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_375stream_ADX = {"stream_ADX", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_375stream_ADX, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_374stream_ADX};
+static PyObject *__pyx_pw_5talib_7_ta_lib_375stream_ADX(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
-  double __pyx_v_penetration;
+  int __pyx_v_timeperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_CDLABANDONEDBABY (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_ADX (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,&__pyx_n_s_penetration,0};
-    PyObject* values[5] = {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  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
-        CYTHON_FALLTHROUGH;
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,&__pyx_mstate_global->__pyx_n_u_timeperiod,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 183, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 183, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 183, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 183, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 183, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLABANDONEDBABY", 0, 4, 5, 1); __PYX_ERR(3, 831, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLABANDONEDBABY", 0, 4, 5, 2); __PYX_ERR(3, 831, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLABANDONEDBABY", 0, 4, 5, 3); __PYX_ERR(3, 831, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  4:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_penetration);
-          if (value) { values[4] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_CDLABANDONEDBABY") < 0)) __PYX_ERR(3, 831, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_ADX", 0) < (0)) __PYX_ERR(5, 183, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 3; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_ADX", 0, 3, 4, i); __PYX_ERR(5, 183, __pyx_L3_error) }
       }
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 183, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 183, __pyx_L3_error)
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 183, __pyx_L3_error)
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 183, __pyx_L3_error)
         break;
         default: goto __pyx_L5_argtuple_error;
       }
     }
-    __pyx_v_open = ((PyArrayObject *)values[0]);
-    __pyx_v_high = ((PyArrayObject *)values[1]);
-    __pyx_v_low = ((PyArrayObject *)values[2]);
-    __pyx_v_close = ((PyArrayObject *)values[3]);
-    if (values[4]) {
-      __pyx_v_penetration = __pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_penetration == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 831, __pyx_L3_error)
+    __pyx_v_high = ((PyArrayObject *)values[0]);
+    __pyx_v_low = ((PyArrayObject *)values[1]);
+    __pyx_v_close = ((PyArrayObject *)values[2]);
+    if (values[3]) {
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[3]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 185, __pyx_L3_error)
     } else {
-      __pyx_v_penetration = ((double)0.3);
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
     }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_CDLABANDONEDBABY", 0, 4, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 831, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_ADX", 0, 3, 4, __pyx_nargs); __PYX_ERR(5, 183, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLABANDONEDBABY", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_ADX", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 831, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 831, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 831, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 831, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_406stream_CDLABANDONEDBABY(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_penetration);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 185, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 185, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 185, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_374stream_ADX(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_timeperiod);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_406stream_CDLABANDONEDBABY(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_374stream_ADX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
-  double *__pyx_v_open_data;
   double *__pyx_v_high_data;
   double *__pyx_v_low_data;
   double *__pyx_v_close_data;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  int __pyx_v_outinteger;
+  double __pyx_v_outreal;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
-  __Pyx_RefNannySetupContext("stream_CDLABANDONEDBABY", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_open);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_ADX", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 853, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_v_open_data = ((double *)__pyx_v_open->data);
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 855, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 206, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_high_data = ((double *)__pyx_v_high->data);
+  __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 857, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 208, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_low_data = ((double *)__pyx_v_low->data);
+  __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 859, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 210, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_close_data = ((double *)__pyx_v_close->data);
+  __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close));
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(3, 861, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 212, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
-  __pyx_v_outinteger = 0;
+  __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
 
-  __pyx_v_retCode = TA_CDLABANDONEDBABY((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, __pyx_v_penetration, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
+  __pyx_v_retCode = TA_ADX((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLABANDONEDBABY, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 864, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_ADX, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 215, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 865, __pyx_L1_error)
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 216, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -42343,10 +51708,9 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_406stream_CDLABANDONEDBABY(CYTHON_UNUS
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLABANDONEDBABY", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_ADX", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_open);
   __Pyx_XDECREF((PyObject *)__pyx_v_high);
   __Pyx_XDECREF((PyObject *)__pyx_v_low);
   __Pyx_XDECREF((PyObject *)__pyx_v_close);
@@ -42357,159 +51721,191 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_406stream_CDLABANDONEDBABY(CYTHON_UNUS
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_409stream_CDLADVANCEBLOCK(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_408stream_CDLADVANCEBLOCK[] = " CDLADVANCEBLOCK(open, high, low, close)\n\n    Advance Block (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_409stream_CDLADVANCEBLOCK = {"stream_CDLADVANCEBLOCK", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_409stream_CDLADVANCEBLOCK, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_408stream_CDLADVANCEBLOCK};
-static PyObject *__pyx_pw_5talib_7_ta_lib_409stream_CDLADVANCEBLOCK(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_open = 0;
+static PyObject *__pyx_pw_5talib_7_ta_lib_377stream_ADXR(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_376stream_ADXR, "stream_ADXR(ndarray high, ndarray low, ndarray close, int timeperiod=-0x80000000)\n\nADXR(high, low, close[, timeperiod=?])\n\nAverage Directional Movement Index Rating (Momentum Indicators)\n\nInputs:\n    prices: ['high', 'low', 'close']\nParameters:\n    timeperiod: 14\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_377stream_ADXR = {"stream_ADXR", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_377stream_ADXR, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_376stream_ADXR};
+static PyObject *__pyx_pw_5talib_7_ta_lib_377stream_ADXR(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
+  int __pyx_v_timeperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_CDLADVANCEBLOCK (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_ADXR (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,&__pyx_mstate_global->__pyx_n_u_timeperiod,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 218, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 218, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 218, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 218, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 218, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLADVANCEBLOCK", 1, 4, 4, 1); __PYX_ERR(3, 869, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLADVANCEBLOCK", 1, 4, 4, 2); __PYX_ERR(3, 869, __pyx_L3_error)
-        }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_ADXR", 0) < (0)) __PYX_ERR(5, 218, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 3; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_ADXR", 0, 3, 4, i); __PYX_ERR(5, 218, __pyx_L3_error) }
+      }
+    } else {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 218, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLADVANCEBLOCK", 1, 4, 4, 3); __PYX_ERR(3, 869, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_CDLADVANCEBLOCK") < 0)) __PYX_ERR(3, 869, __pyx_L3_error)
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 218, __pyx_L3_error)
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 218, __pyx_L3_error)
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 218, __pyx_L3_error)
+        break;
+        default: goto __pyx_L5_argtuple_error;
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
-      goto __pyx_L5_argtuple_error;
+    }
+    __pyx_v_high = ((PyArrayObject *)values[0]);
+    __pyx_v_low = ((PyArrayObject *)values[1]);
+    __pyx_v_close = ((PyArrayObject *)values[2]);
+    if (values[3]) {
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[3]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 220, __pyx_L3_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);
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
     }
-    __pyx_v_open = ((PyArrayObject *)values[0]);
-    __pyx_v_high = ((PyArrayObject *)values[1]);
-    __pyx_v_low = ((PyArrayObject *)values[2]);
-    __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_CDLADVANCEBLOCK", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 869, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_ADXR", 0, 3, 4, __pyx_nargs); __PYX_ERR(5, 218, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLADVANCEBLOCK", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_ADXR", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 869, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 869, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 869, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 869, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_408stream_CDLADVANCEBLOCK(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 220, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 220, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 220, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_376stream_ADXR(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_timeperiod);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_408stream_CDLADVANCEBLOCK(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_376stream_ADXR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
-  double *__pyx_v_open_data;
   double *__pyx_v_high_data;
   double *__pyx_v_low_data;
   double *__pyx_v_close_data;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  int __pyx_v_outinteger;
+  double __pyx_v_outreal;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
-  __Pyx_RefNannySetupContext("stream_CDLADVANCEBLOCK", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_open);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_ADXR", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 889, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_v_open_data = ((double *)__pyx_v_open->data);
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 891, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 241, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_high_data = ((double *)__pyx_v_high->data);
+  __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 893, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 243, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_low_data = ((double *)__pyx_v_low->data);
+  __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 895, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 245, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_close_data = ((double *)__pyx_v_close->data);
+  __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close));
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(3, 897, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 247, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
-  __pyx_v_outinteger = 0;
+  __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
 
-  __pyx_v_retCode = TA_CDLADVANCEBLOCK((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
+  __pyx_v_retCode = TA_ADXR((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLADVANCEBLOCK, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 900, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_ADXR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 250, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 901, __pyx_L1_error)
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 251, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -42519,10 +51915,9 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_408stream_CDLADVANCEBLOCK(CYTHON_UNUSE
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLADVANCEBLOCK", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_ADXR", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_open);
   __Pyx_XDECREF((PyObject *)__pyx_v_high);
   __Pyx_XDECREF((PyObject *)__pyx_v_low);
   __Pyx_XDECREF((PyObject *)__pyx_v_close);
@@ -42533,159 +51928,181 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_408stream_CDLADVANCEBLOCK(CYTHON_UNUSE
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_411stream_CDLBELTHOLD(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_410stream_CDLBELTHOLD[] = " CDLBELTHOLD(open, high, low, close)\n\n    Belt-hold (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_411stream_CDLBELTHOLD = {"stream_CDLBELTHOLD", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_411stream_CDLBELTHOLD, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_410stream_CDLBELTHOLD};
-static PyObject *__pyx_pw_5talib_7_ta_lib_411stream_CDLBELTHOLD(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_open = 0;
-  PyArrayObject *__pyx_v_high = 0;
-  PyArrayObject *__pyx_v_low = 0;
-  PyArrayObject *__pyx_v_close = 0;
+static PyObject *__pyx_pw_5talib_7_ta_lib_379stream_APO(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_378stream_APO, "stream_APO(ndarray real, int fastperiod=-0x80000000, int slowperiod=-0x80000000, int matype=0)\n\nAPO(real[, fastperiod=?, slowperiod=?, matype=?])\n\nAbsolute Price Oscillator (Momentum Indicators)\n\nInputs:\n    real: (any ndarray)\nParameters:\n    fastperiod: 12\n    slowperiod: 26\n    matype: 0 (Simple Moving Average)\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_379stream_APO = {"stream_APO", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_379stream_APO, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_378stream_APO};
+static PyObject *__pyx_pw_5talib_7_ta_lib_379stream_APO(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_real = 0;
+  int __pyx_v_fastperiod;
+  int __pyx_v_slowperiod;
+  int __pyx_v_matype;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_CDLBELTHOLD (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_APO (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_fastperiod,&__pyx_mstate_global->__pyx_n_u_slowperiod,&__pyx_mstate_global->__pyx_n_u_matype,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 253, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 253, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 253, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 253, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 253, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_APO", 0) < (0)) __PYX_ERR(5, 253, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_APO", 0, 1, 4, i); __PYX_ERR(5, 253, __pyx_L3_error) }
+      }
+    } else {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 253, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLBELTHOLD", 1, 4, 4, 1); __PYX_ERR(3, 905, __pyx_L3_error)
-        }
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 253, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLBELTHOLD", 1, 4, 4, 2); __PYX_ERR(3, 905, __pyx_L3_error)
-        }
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 253, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLBELTHOLD", 1, 4, 4, 3); __PYX_ERR(3, 905, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_CDLBELTHOLD") < 0)) __PYX_ERR(3, 905, __pyx_L3_error)
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 253, __pyx_L3_error)
+        break;
+        default: goto __pyx_L5_argtuple_error;
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
-      goto __pyx_L5_argtuple_error;
+    }
+    __pyx_v_real = ((PyArrayObject *)values[0]);
+    if (values[1]) {
+      __pyx_v_fastperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_fastperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 255, __pyx_L3_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);
+      __pyx_v_fastperiod = ((int)((int)-2147483648));
+    }
+    if (values[2]) {
+      __pyx_v_slowperiod = __Pyx_PyLong_As_int(values[2]); if (unlikely((__pyx_v_slowperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 255, __pyx_L3_error)
+    } else {
+      __pyx_v_slowperiod = ((int)((int)-2147483648));
+    }
+    if (values[3]) {
+      __pyx_v_matype = __Pyx_PyLong_As_int(values[3]); if (unlikely((__pyx_v_matype == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 255, __pyx_L3_error)
+    } else {
+      __pyx_v_matype = ((int)((int)0));
     }
-    __pyx_v_open = ((PyArrayObject *)values[0]);
-    __pyx_v_high = ((PyArrayObject *)values[1]);
-    __pyx_v_low = ((PyArrayObject *)values[2]);
-    __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_CDLBELTHOLD", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 905, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_APO", 0, 1, 4, __pyx_nargs); __PYX_ERR(5, 253, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLBELTHOLD", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_APO", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 905, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 905, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 905, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 905, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_410stream_CDLBELTHOLD(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 255, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_378stream_APO(__pyx_self, __pyx_v_real, __pyx_v_fastperiod, __pyx_v_slowperiod, __pyx_v_matype);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_410stream_CDLBELTHOLD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_378stream_APO(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_fastperiod, int __pyx_v_slowperiod, int __pyx_v_matype) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
-  double *__pyx_v_open_data;
-  double *__pyx_v_high_data;
-  double *__pyx_v_low_data;
-  double *__pyx_v_close_data;
+  double *__pyx_v_real_data;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  int __pyx_v_outinteger;
+  double __pyx_v_outreal;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  npy_intp __pyx_t_2;
-  __Pyx_RefNannySetupContext("stream_CDLBELTHOLD", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_open);
-  __Pyx_INCREF((PyObject *)__pyx_v_high);
-  __Pyx_INCREF((PyObject *)__pyx_v_low);
-  __Pyx_INCREF((PyObject *)__pyx_v_close);
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 925, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_v_open_data = ((double *)__pyx_v_open->data);
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 927, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_v_high_data = ((double *)__pyx_v_high->data);
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 929, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_v_low_data = ((double *)__pyx_v_low->data);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_APO", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 931, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 276, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_close_data = ((double *)__pyx_v_close->data);
+  __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real));
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(3, 933, __pyx_L1_error)
-  __pyx_v_length = __pyx_t_2;
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
-  __pyx_v_outinteger = 0;
+  __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
 
-  __pyx_v_retCode = TA_CDLBELTHOLD((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
+  __pyx_v_retCode = TA_APO((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_fastperiod, __pyx_v_slowperiod, __pyx_v_matype, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLBELTHOLD, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 936, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_APO, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 281, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 937, __pyx_L1_error)
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 282, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -42695,13 +52112,10 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_410stream_CDLBELTHOLD(CYTHON_UNUSED Py
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLBELTHOLD", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_APO", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_open);
-  __Pyx_XDECREF((PyObject *)__pyx_v_high);
-  __Pyx_XDECREF((PyObject *)__pyx_v_low);
-  __Pyx_XDECREF((PyObject *)__pyx_v_close);
+  __Pyx_XDECREF((PyObject *)__pyx_v_real);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -42709,175 +52123,204 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_410stream_CDLBELTHOLD(CYTHON_UNUSED Py
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_413stream_CDLBREAKAWAY(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_412stream_CDLBREAKAWAY[] = " CDLBREAKAWAY(open, high, low, close)\n\n    Breakaway (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_413stream_CDLBREAKAWAY = {"stream_CDLBREAKAWAY", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_413stream_CDLBREAKAWAY, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_412stream_CDLBREAKAWAY};
-static PyObject *__pyx_pw_5talib_7_ta_lib_413stream_CDLBREAKAWAY(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_open = 0;
+static PyObject *__pyx_pw_5talib_7_ta_lib_381stream_AROON(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_380stream_AROON, "stream_AROON(ndarray high, ndarray low, int timeperiod=-0x80000000)\n\nAROON(high, low[, timeperiod=?])\n\nAroon (Momentum Indicators)\n\nInputs:\n    prices: ['high', 'low']\nParameters:\n    timeperiod: 14\nOutputs:\n    aroondown\n    aroonup");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_381stream_AROON = {"stream_AROON", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_381stream_AROON, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_380stream_AROON};
+static PyObject *__pyx_pw_5talib_7_ta_lib_381stream_AROON(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
-  PyArrayObject *__pyx_v_close = 0;
+  int __pyx_v_timeperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[3] = {0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_CDLBREAKAWAY (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_AROON (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_timeperiod,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 284, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 284, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 284, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 284, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLBREAKAWAY", 1, 4, 4, 1); __PYX_ERR(3, 941, __pyx_L3_error)
-        }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_AROON", 0) < (0)) __PYX_ERR(5, 284, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_AROON", 0, 2, 3, i); __PYX_ERR(5, 284, __pyx_L3_error) }
+      }
+    } else {
+      switch (__pyx_nargs) {
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 284, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLBREAKAWAY", 1, 4, 4, 2); __PYX_ERR(3, 941, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLBREAKAWAY", 1, 4, 4, 3); __PYX_ERR(3, 941, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_CDLBREAKAWAY") < 0)) __PYX_ERR(3, 941, __pyx_L3_error)
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 284, __pyx_L3_error)
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 284, __pyx_L3_error)
+        break;
+        default: goto __pyx_L5_argtuple_error;
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
-      goto __pyx_L5_argtuple_error;
+    }
+    __pyx_v_high = ((PyArrayObject *)values[0]);
+    __pyx_v_low = ((PyArrayObject *)values[1]);
+    if (values[2]) {
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[2]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 286, __pyx_L3_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);
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
     }
-    __pyx_v_open = ((PyArrayObject *)values[0]);
-    __pyx_v_high = ((PyArrayObject *)values[1]);
-    __pyx_v_low = ((PyArrayObject *)values[2]);
-    __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_CDLBREAKAWAY", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 941, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_AROON", 0, 2, 3, __pyx_nargs); __PYX_ERR(5, 284, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLBREAKAWAY", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_AROON", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 941, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 941, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 941, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 941, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_412stream_CDLBREAKAWAY(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 286, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 286, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_380stream_AROON(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_timeperiod);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_412stream_CDLBREAKAWAY(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_380stream_AROON(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, int __pyx_v_timeperiod) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
-  double *__pyx_v_open_data;
   double *__pyx_v_high_data;
   double *__pyx_v_low_data;
-  double *__pyx_v_close_data;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  int __pyx_v_outinteger;
+  double __pyx_v_outaroondown;
+  double __pyx_v_outaroonup;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
-  __Pyx_RefNannySetupContext("stream_CDLBREAKAWAY", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_open);
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_AROON", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
-  __Pyx_INCREF((PyObject *)__pyx_v_close);
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 961, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
 
-  __pyx_v_open_data = ((double *)__pyx_v_open->data);
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 963, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 308, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_high_data = ((double *)__pyx_v_high->data);
+  __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 965, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 310, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_low_data = ((double *)__pyx_v_low->data);
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 967, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_v_close_data = ((double *)__pyx_v_close->data);
+  __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low));
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(3, 969, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_high, __pyx_v_low); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 312, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
-  __pyx_v_outinteger = 0;
+  __pyx_v_outaroondown = __pyx_v_5talib_7_ta_lib_NaN;
 
-  __pyx_v_retCode = TA_CDLBREAKAWAY((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
+  __pyx_v_outaroonup = __pyx_v_5talib_7_ta_lib_NaN;
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLBREAKAWAY, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 972, __pyx_L1_error)
+  __pyx_v_retCode = TA_AROON((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_high_data, __pyx_v_low_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outaroondown), (&__pyx_v_outaroonup));
+
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_AROON, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 316, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 973, __pyx_L1_error)
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outaroondown); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 317, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_r = __pyx_t_1;
-  __pyx_t_1 = 0;
+  __pyx_t_3 = PyFloat_FromDouble(__pyx_v_outaroonup); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 317, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 317, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_GIVEREF(__pyx_t_1);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1) != (0)) __PYX_ERR(5, 317, __pyx_L1_error);
+  __Pyx_GIVEREF(__pyx_t_3);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_3) != (0)) __PYX_ERR(5, 317, __pyx_L1_error);
+  __pyx_t_1 = 0;
+  __pyx_t_3 = 0;
+  __pyx_r = __pyx_t_4;
+  __pyx_t_4 = 0;
   goto __pyx_L0;
 
 
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLBREAKAWAY", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_AddTraceback("talib._ta_lib.stream_AROON", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_open);
   __Pyx_XDECREF((PyObject *)__pyx_v_high);
   __Pyx_XDECREF((PyObject *)__pyx_v_low);
-  __Pyx_XDECREF((PyObject *)__pyx_v_close);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -42885,159 +52328,173 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_412stream_CDLBREAKAWAY(CYTHON_UNUSED P
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_415stream_CDLCLOSINGMARUBOZU(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_414stream_CDLCLOSINGMARUBOZU[] = " CDLCLOSINGMARUBOZU(open, high, low, close)\n\n    Closing Marubozu (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_415stream_CDLCLOSINGMARUBOZU = {"stream_CDLCLOSINGMARUBOZU", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_415stream_CDLCLOSINGMARUBOZU, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_414stream_CDLCLOSINGMARUBOZU};
-static PyObject *__pyx_pw_5talib_7_ta_lib_415stream_CDLCLOSINGMARUBOZU(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_open = 0;
+static PyObject *__pyx_pw_5talib_7_ta_lib_383stream_AROONOSC(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_382stream_AROONOSC, "stream_AROONOSC(ndarray high, ndarray low, int timeperiod=-0x80000000)\n\nAROONOSC(high, low[, timeperiod=?])\n\nAroon Oscillator (Momentum Indicators)\n\nInputs:\n    prices: ['high', 'low']\nParameters:\n    timeperiod: 14\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_383stream_AROONOSC = {"stream_AROONOSC", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_383stream_AROONOSC, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_382stream_AROONOSC};
+static PyObject *__pyx_pw_5talib_7_ta_lib_383stream_AROONOSC(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
-  PyArrayObject *__pyx_v_close = 0;
+  int __pyx_v_timeperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[3] = {0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_CDLCLOSINGMARUBOZU (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_AROONOSC (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_timeperiod,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 319, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 319, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 319, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 319, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLCLOSINGMARUBOZU", 1, 4, 4, 1); __PYX_ERR(3, 977, __pyx_L3_error)
-        }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_AROONOSC", 0) < (0)) __PYX_ERR(5, 319, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_AROONOSC", 0, 2, 3, i); __PYX_ERR(5, 319, __pyx_L3_error) }
+      }
+    } else {
+      switch (__pyx_nargs) {
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 319, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLCLOSINGMARUBOZU", 1, 4, 4, 2); __PYX_ERR(3, 977, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLCLOSINGMARUBOZU", 1, 4, 4, 3); __PYX_ERR(3, 977, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_CDLCLOSINGMARUBOZU") < 0)) __PYX_ERR(3, 977, __pyx_L3_error)
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 319, __pyx_L3_error)
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 319, __pyx_L3_error)
+        break;
+        default: goto __pyx_L5_argtuple_error;
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
-      goto __pyx_L5_argtuple_error;
+    }
+    __pyx_v_high = ((PyArrayObject *)values[0]);
+    __pyx_v_low = ((PyArrayObject *)values[1]);
+    if (values[2]) {
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[2]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 321, __pyx_L3_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);
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
     }
-    __pyx_v_open = ((PyArrayObject *)values[0]);
-    __pyx_v_high = ((PyArrayObject *)values[1]);
-    __pyx_v_low = ((PyArrayObject *)values[2]);
-    __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_CDLCLOSINGMARUBOZU", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 977, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_AROONOSC", 0, 2, 3, __pyx_nargs); __PYX_ERR(5, 319, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLCLOSINGMARUBOZU", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_AROONOSC", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 977, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 977, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 977, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 977, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_414stream_CDLCLOSINGMARUBOZU(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 321, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 321, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_382stream_AROONOSC(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_timeperiod);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_414stream_CDLCLOSINGMARUBOZU(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_382stream_AROONOSC(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, int __pyx_v_timeperiod) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
-  double *__pyx_v_open_data;
   double *__pyx_v_high_data;
   double *__pyx_v_low_data;
-  double *__pyx_v_close_data;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  int __pyx_v_outinteger;
+  double __pyx_v_outreal;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
-  __Pyx_RefNannySetupContext("stream_CDLCLOSINGMARUBOZU", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_open);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_AROONOSC", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
-  __Pyx_INCREF((PyObject *)__pyx_v_close);
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 997, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
 
-  __pyx_v_open_data = ((double *)__pyx_v_open->data);
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 999, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 341, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_high_data = ((double *)__pyx_v_high->data);
+  __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1001, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 343, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_low_data = ((double *)__pyx_v_low->data);
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1003, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_v_close_data = ((double *)__pyx_v_close->data);
+  __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low));
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(3, 1005, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_high, __pyx_v_low); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 345, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
-  __pyx_v_outinteger = 0;
+  __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
 
-  __pyx_v_retCode = TA_CDLCLOSINGMARUBOZU((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
+  __pyx_v_retCode = TA_AROONOSC((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_high_data, __pyx_v_low_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLCLOSINGMARUBOZU, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1008, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_AROONOSC, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 348, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1009, __pyx_L1_error)
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 349, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -43047,13 +52504,11 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_414stream_CDLCLOSINGMARUBOZU(CYTHON_UN
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLCLOSINGMARUBOZU", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_AROONOSC", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_open);
   __Pyx_XDECREF((PyObject *)__pyx_v_high);
   __Pyx_XDECREF((PyObject *)__pyx_v_low);
-  __Pyx_XDECREF((PyObject *)__pyx_v_close);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -43061,159 +52516,136 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_414stream_CDLCLOSINGMARUBOZU(CYTHON_UN
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_417stream_CDLCONCEALBABYSWALL(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_416stream_CDLCONCEALBABYSWALL[] = " CDLCONCEALBABYSWALL(open, high, low, close)\n\n    Concealing Baby Swallow (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_417stream_CDLCONCEALBABYSWALL = {"stream_CDLCONCEALBABYSWALL", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_417stream_CDLCONCEALBABYSWALL, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_416stream_CDLCONCEALBABYSWALL};
-static PyObject *__pyx_pw_5talib_7_ta_lib_417stream_CDLCONCEALBABYSWALL(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_open = 0;
-  PyArrayObject *__pyx_v_high = 0;
-  PyArrayObject *__pyx_v_low = 0;
-  PyArrayObject *__pyx_v_close = 0;
+static PyObject *__pyx_pw_5talib_7_ta_lib_385stream_ASIN(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_384stream_ASIN, "stream_ASIN(ndarray real)\n\nASIN(real)\n\nVector Trigonometric ASin (Math Transform)\n\nInputs:\n    real: (any ndarray)\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_385stream_ASIN = {"stream_ASIN", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_385stream_ASIN, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_384stream_ASIN};
+static PyObject *__pyx_pw_5talib_7_ta_lib_385stream_ASIN(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_real = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_CDLCONCEALBABYSWALL (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_ASIN (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 351, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 351, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLCONCEALBABYSWALL", 1, 4, 4, 1); __PYX_ERR(3, 1013, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLCONCEALBABYSWALL", 1, 4, 4, 2); __PYX_ERR(3, 1013, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLCONCEALBABYSWALL", 1, 4, 4, 3); __PYX_ERR(3, 1013, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_CDLCONCEALBABYSWALL") < 0)) __PYX_ERR(3, 1013, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_ASIN", 0) < (0)) __PYX_ERR(5, 351, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_ASIN", 1, 1, 1, i); __PYX_ERR(5, 351, __pyx_L3_error) }
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
+    } else if (unlikely(__pyx_nargs != 1)) {
       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[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 351, __pyx_L3_error)
     }
-    __pyx_v_open = ((PyArrayObject *)values[0]);
-    __pyx_v_high = ((PyArrayObject *)values[1]);
-    __pyx_v_low = ((PyArrayObject *)values[2]);
-    __pyx_v_close = ((PyArrayObject *)values[3]);
+    __pyx_v_real = ((PyArrayObject *)values[0]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_CDLCONCEALBABYSWALL", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 1013, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_ASIN", 1, 1, 1, __pyx_nargs); __PYX_ERR(5, 351, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLCONCEALBABYSWALL", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_ASIN", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 1013, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 1013, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 1013, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 1013, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_416stream_CDLCONCEALBABYSWALL(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 353, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_384stream_ASIN(__pyx_self, __pyx_v_real);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_416stream_CDLCONCEALBABYSWALL(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_384stream_ASIN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
-  double *__pyx_v_open_data;
-  double *__pyx_v_high_data;
-  double *__pyx_v_low_data;
-  double *__pyx_v_close_data;
+  double *__pyx_v_real_data;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  int __pyx_v_outinteger;
+  double __pyx_v_outreal;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  npy_intp __pyx_t_2;
-  __Pyx_RefNannySetupContext("stream_CDLCONCEALBABYSWALL", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_open);
-  __Pyx_INCREF((PyObject *)__pyx_v_high);
-  __Pyx_INCREF((PyObject *)__pyx_v_low);
-  __Pyx_INCREF((PyObject *)__pyx_v_close);
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1033, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_v_open_data = ((double *)__pyx_v_open->data);
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1035, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_v_high_data = ((double *)__pyx_v_high->data);
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1037, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_v_low_data = ((double *)__pyx_v_low->data);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_ASIN", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1039, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 370, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_close_data = ((double *)__pyx_v_close->data);
+  __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real));
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(3, 1041, __pyx_L1_error)
-  __pyx_v_length = __pyx_t_2;
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
-  __pyx_v_outinteger = 0;
+  __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
 
-  __pyx_v_retCode = TA_CDLCONCEALBABYSWALL((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
+  __pyx_v_retCode = TA_ASIN((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLCONCEALBABYSWALL, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1044, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_ASIN, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 375, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1045, __pyx_L1_error)
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 376, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -43223,13 +52655,10 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_416stream_CDLCONCEALBABYSWALL(CYTHON_U
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLCONCEALBABYSWALL", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_ASIN", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_open);
-  __Pyx_XDECREF((PyObject *)__pyx_v_high);
-  __Pyx_XDECREF((PyObject *)__pyx_v_low);
-  __Pyx_XDECREF((PyObject *)__pyx_v_close);
+  __Pyx_XDECREF((PyObject *)__pyx_v_real);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -43237,159 +52666,136 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_416stream_CDLCONCEALBABYSWALL(CYTHON_U
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_419stream_CDLCOUNTERATTACK(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_418stream_CDLCOUNTERATTACK[] = " CDLCOUNTERATTACK(open, high, low, close)\n\n    Counterattack (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_419stream_CDLCOUNTERATTACK = {"stream_CDLCOUNTERATTACK", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_419stream_CDLCOUNTERATTACK, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_418stream_CDLCOUNTERATTACK};
-static PyObject *__pyx_pw_5talib_7_ta_lib_419stream_CDLCOUNTERATTACK(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_open = 0;
-  PyArrayObject *__pyx_v_high = 0;
-  PyArrayObject *__pyx_v_low = 0;
-  PyArrayObject *__pyx_v_close = 0;
+static PyObject *__pyx_pw_5talib_7_ta_lib_387stream_ATAN(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_386stream_ATAN, "stream_ATAN(ndarray real)\n\nATAN(real)\n\nVector Trigonometric ATan (Math Transform)\n\nInputs:\n    real: (any ndarray)\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_387stream_ATAN = {"stream_ATAN", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_387stream_ATAN, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_386stream_ATAN};
+static PyObject *__pyx_pw_5talib_7_ta_lib_387stream_ATAN(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_real = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_CDLCOUNTERATTACK (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_ATAN (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 378, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 378, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLCOUNTERATTACK", 1, 4, 4, 1); __PYX_ERR(3, 1049, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLCOUNTERATTACK", 1, 4, 4, 2); __PYX_ERR(3, 1049, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLCOUNTERATTACK", 1, 4, 4, 3); __PYX_ERR(3, 1049, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_CDLCOUNTERATTACK") < 0)) __PYX_ERR(3, 1049, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_ATAN", 0) < (0)) __PYX_ERR(5, 378, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_ATAN", 1, 1, 1, i); __PYX_ERR(5, 378, __pyx_L3_error) }
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
+    } else if (unlikely(__pyx_nargs != 1)) {
       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[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 378, __pyx_L3_error)
     }
-    __pyx_v_open = ((PyArrayObject *)values[0]);
-    __pyx_v_high = ((PyArrayObject *)values[1]);
-    __pyx_v_low = ((PyArrayObject *)values[2]);
-    __pyx_v_close = ((PyArrayObject *)values[3]);
+    __pyx_v_real = ((PyArrayObject *)values[0]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_CDLCOUNTERATTACK", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 1049, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_ATAN", 1, 1, 1, __pyx_nargs); __PYX_ERR(5, 378, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLCOUNTERATTACK", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_ATAN", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 1049, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 1049, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 1049, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 1049, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_418stream_CDLCOUNTERATTACK(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 380, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_386stream_ATAN(__pyx_self, __pyx_v_real);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_418stream_CDLCOUNTERATTACK(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_386stream_ATAN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
-  double *__pyx_v_open_data;
-  double *__pyx_v_high_data;
-  double *__pyx_v_low_data;
-  double *__pyx_v_close_data;
+  double *__pyx_v_real_data;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  int __pyx_v_outinteger;
+  double __pyx_v_outreal;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  npy_intp __pyx_t_2;
-  __Pyx_RefNannySetupContext("stream_CDLCOUNTERATTACK", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_open);
-  __Pyx_INCREF((PyObject *)__pyx_v_high);
-  __Pyx_INCREF((PyObject *)__pyx_v_low);
-  __Pyx_INCREF((PyObject *)__pyx_v_close);
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1069, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_v_open_data = ((double *)__pyx_v_open->data);
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1071, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_v_high_data = ((double *)__pyx_v_high->data);
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1073, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_v_low_data = ((double *)__pyx_v_low->data);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_ATAN", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1075, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 397, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_close_data = ((double *)__pyx_v_close->data);
+  __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real));
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(3, 1077, __pyx_L1_error)
-  __pyx_v_length = __pyx_t_2;
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
-  __pyx_v_outinteger = 0;
+  __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
 
-  __pyx_v_retCode = TA_CDLCOUNTERATTACK((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
+  __pyx_v_retCode = TA_ATAN((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLCOUNTERATTACK, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1080, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_ATAN, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 402, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1081, __pyx_L1_error)
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 403, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -43399,13 +52805,10 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_418stream_CDLCOUNTERATTACK(CYTHON_UNUS
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLCOUNTERATTACK", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_ATAN", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_open);
-  __Pyx_XDECREF((PyObject *)__pyx_v_high);
-  __Pyx_XDECREF((PyObject *)__pyx_v_low);
-  __Pyx_XDECREF((PyObject *)__pyx_v_close);
+  __Pyx_XDECREF((PyObject *)__pyx_v_real);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -43413,177 +52816,191 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_418stream_CDLCOUNTERATTACK(CYTHON_UNUS
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_421stream_CDLDARKCLOUDCOVER(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_420stream_CDLDARKCLOUDCOVER[] = " CDLDARKCLOUDCOVER(open, high, low, close[, penetration=?])\n\n    Dark Cloud Cover (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Parameters:\n        penetration: 0.5\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_421stream_CDLDARKCLOUDCOVER = {"stream_CDLDARKCLOUDCOVER", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_421stream_CDLDARKCLOUDCOVER, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_420stream_CDLDARKCLOUDCOVER};
-static PyObject *__pyx_pw_5talib_7_ta_lib_421stream_CDLDARKCLOUDCOVER(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_open = 0;
+static PyObject *__pyx_pw_5talib_7_ta_lib_389stream_ATR(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_388stream_ATR, "stream_ATR(ndarray high, ndarray low, ndarray close, int timeperiod=-0x80000000)\n\nATR(high, low, close[, timeperiod=?])\n\nAverage True Range (Volatility Indicators)\n\nInputs:\n    prices: ['high', 'low', 'close']\nParameters:\n    timeperiod: 14\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_389stream_ATR = {"stream_ATR", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_389stream_ATR, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_388stream_ATR};
+static PyObject *__pyx_pw_5talib_7_ta_lib_389stream_ATR(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
-  double __pyx_v_penetration;
+  int __pyx_v_timeperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_CDLDARKCLOUDCOVER (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_ATR (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,&__pyx_n_s_penetration,0};
-    PyObject* values[5] = {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  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
-        CYTHON_FALLTHROUGH;
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,&__pyx_mstate_global->__pyx_n_u_timeperiod,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 405, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 405, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 405, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 405, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 405, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLDARKCLOUDCOVER", 0, 4, 5, 1); __PYX_ERR(3, 1085, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLDARKCLOUDCOVER", 0, 4, 5, 2); __PYX_ERR(3, 1085, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLDARKCLOUDCOVER", 0, 4, 5, 3); __PYX_ERR(3, 1085, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  4:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_penetration);
-          if (value) { values[4] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_CDLDARKCLOUDCOVER") < 0)) __PYX_ERR(3, 1085, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_ATR", 0) < (0)) __PYX_ERR(5, 405, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 3; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_ATR", 0, 3, 4, i); __PYX_ERR(5, 405, __pyx_L3_error) }
       }
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 405, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 405, __pyx_L3_error)
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 405, __pyx_L3_error)
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 405, __pyx_L3_error)
         break;
         default: goto __pyx_L5_argtuple_error;
       }
     }
-    __pyx_v_open = ((PyArrayObject *)values[0]);
-    __pyx_v_high = ((PyArrayObject *)values[1]);
-    __pyx_v_low = ((PyArrayObject *)values[2]);
-    __pyx_v_close = ((PyArrayObject *)values[3]);
-    if (values[4]) {
-      __pyx_v_penetration = __pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_penetration == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 1085, __pyx_L3_error)
+    __pyx_v_high = ((PyArrayObject *)values[0]);
+    __pyx_v_low = ((PyArrayObject *)values[1]);
+    __pyx_v_close = ((PyArrayObject *)values[2]);
+    if (values[3]) {
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[3]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 407, __pyx_L3_error)
     } else {
-      __pyx_v_penetration = ((double)0.5);
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
     }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_CDLDARKCLOUDCOVER", 0, 4, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 1085, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_ATR", 0, 3, 4, __pyx_nargs); __PYX_ERR(5, 405, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLDARKCLOUDCOVER", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_ATR", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 1085, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 1085, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 1085, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 1085, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_420stream_CDLDARKCLOUDCOVER(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_penetration);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 407, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 407, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 407, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_388stream_ATR(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_timeperiod);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_420stream_CDLDARKCLOUDCOVER(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_388stream_ATR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
-  double *__pyx_v_open_data;
   double *__pyx_v_high_data;
   double *__pyx_v_low_data;
   double *__pyx_v_close_data;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  int __pyx_v_outinteger;
+  double __pyx_v_outreal;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
-  __Pyx_RefNannySetupContext("stream_CDLDARKCLOUDCOVER", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_open);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_ATR", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1107, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_v_open_data = ((double *)__pyx_v_open->data);
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1109, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 428, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_high_data = ((double *)__pyx_v_high->data);
+  __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1111, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 430, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_low_data = ((double *)__pyx_v_low->data);
+  __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1113, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 432, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_close_data = ((double *)__pyx_v_close->data);
+  __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close));
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(3, 1115, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 434, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
-  __pyx_v_outinteger = 0;
+  __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
 
-  __pyx_v_retCode = TA_CDLDARKCLOUDCOVER((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, __pyx_v_penetration, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
+  __pyx_v_retCode = TA_ATR((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLDARKCLOUDCOVER, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1118, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_ATR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 437, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1119, __pyx_L1_error)
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 438, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -43593,10 +53010,9 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_420stream_CDLDARKCLOUDCOVER(CYTHON_UNU
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLDARKCLOUDCOVER", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_ATR", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_open);
   __Pyx_XDECREF((PyObject *)__pyx_v_high);
   __Pyx_XDECREF((PyObject *)__pyx_v_low);
   __Pyx_XDECREF((PyObject *)__pyx_v_close);
@@ -43607,99 +53023,129 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_420stream_CDLDARKCLOUDCOVER(CYTHON_UNU
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_423stream_CDLDOJI(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_422stream_CDLDOJI[] = " CDLDOJI(open, high, low, close)\n\n    Doji (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_423stream_CDLDOJI = {"stream_CDLDOJI", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_423stream_CDLDOJI, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_422stream_CDLDOJI};
-static PyObject *__pyx_pw_5talib_7_ta_lib_423stream_CDLDOJI(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_391stream_AVGPRICE(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_390stream_AVGPRICE, "stream_AVGPRICE(ndarray open, ndarray high, ndarray low, ndarray close)\n\nAVGPRICE(open, high, low, close)\n\nAverage Price (Price Transform)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_391stream_AVGPRICE = {"stream_AVGPRICE", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_391stream_AVGPRICE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_390stream_AVGPRICE};
+static PyObject *__pyx_pw_5talib_7_ta_lib_391stream_AVGPRICE(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_open = 0;
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_CDLDOJI (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_AVGPRICE (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 440, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 440, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 440, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 440, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 440, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLDOJI", 1, 4, 4, 1); __PYX_ERR(3, 1123, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLDOJI", 1, 4, 4, 2); __PYX_ERR(3, 1123, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLDOJI", 1, 4, 4, 3); __PYX_ERR(3, 1123, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_CDLDOJI") < 0)) __PYX_ERR(3, 1123, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_AVGPRICE", 0) < (0)) __PYX_ERR(5, 440, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_AVGPRICE", 1, 4, 4, i); __PYX_ERR(5, 440, __pyx_L3_error) }
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
+    } else if (unlikely(__pyx_nargs != 4)) {
       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[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 440, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 440, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 440, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 440, __pyx_L3_error)
     }
     __pyx_v_open = ((PyArrayObject *)values[0]);
     __pyx_v_high = ((PyArrayObject *)values[1]);
     __pyx_v_low = ((PyArrayObject *)values[2]);
     __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_CDLDOJI", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 1123, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_AVGPRICE", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 440, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLDOJI", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_AVGPRICE", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 1123, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 1123, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 1123, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 1123, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_422stream_CDLDOJI(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 442, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 442, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 442, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 442, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_390stream_AVGPRICE(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_422stream_CDLDOJI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_390stream_AVGPRICE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
   double *__pyx_v_open_data;
@@ -43708,58 +53154,61 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_422stream_CDLDOJI(CYTHON_UNUSED PyObje
   double *__pyx_v_close_data;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  int __pyx_v_outinteger;
+  double __pyx_v_outreal;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
-  __Pyx_RefNannySetupContext("stream_CDLDOJI", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_AVGPRICE", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_open);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1143, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 462, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_open_data = ((double *)__pyx_v_open->data);
+  __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1145, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 464, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_high_data = ((double *)__pyx_v_high->data);
+  __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1147, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 466, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_low_data = ((double *)__pyx_v_low->data);
+  __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1149, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 468, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_close_data = ((double *)__pyx_v_close->data);
+  __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close));
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(3, 1151, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 470, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
-  __pyx_v_outinteger = 0;
+  __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
 
-  __pyx_v_retCode = TA_CDLDOJI((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
+  __pyx_v_retCode = TA_AVGPRICE((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLDOJI, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1154, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_AVGPRICE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 473, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1155, __pyx_L1_error)
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 474, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -43769,7 +53218,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_422stream_CDLDOJI(CYTHON_UNUSED PyObje
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLDOJI", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_AVGPRICE", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_open);
@@ -43783,159 +53232,153 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_422stream_CDLDOJI(CYTHON_UNUSED PyObje
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_425stream_CDLDOJISTAR(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_424stream_CDLDOJISTAR[] = " CDLDOJISTAR(open, high, low, close)\n\n    Doji Star (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_425stream_CDLDOJISTAR = {"stream_CDLDOJISTAR", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_425stream_CDLDOJISTAR, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_424stream_CDLDOJISTAR};
-static PyObject *__pyx_pw_5talib_7_ta_lib_425stream_CDLDOJISTAR(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_open = 0;
-  PyArrayObject *__pyx_v_high = 0;
-  PyArrayObject *__pyx_v_low = 0;
-  PyArrayObject *__pyx_v_close = 0;
+static PyObject *__pyx_pw_5talib_7_ta_lib_393stream_AVGDEV(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_392stream_AVGDEV, "stream_AVGDEV(ndarray real, int timeperiod=-0x80000000)\n\nAVGDEV(real[, timeperiod=?])\n\nAverage Deviation (Price Transform)\n\nInputs:\n    real: (any ndarray)\nParameters:\n    timeperiod: 14\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_393stream_AVGDEV = {"stream_AVGDEV", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_393stream_AVGDEV, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_392stream_AVGDEV};
+static PyObject *__pyx_pw_5talib_7_ta_lib_393stream_AVGDEV(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_real = 0;
+  int __pyx_v_timeperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_CDLDOJISTAR (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_AVGDEV (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 476, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 476, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 476, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLDOJISTAR", 1, 4, 4, 1); __PYX_ERR(3, 1159, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_AVGDEV", 0) < (0)) __PYX_ERR(5, 476, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_AVGDEV", 0, 1, 2, i); __PYX_ERR(5, 476, __pyx_L3_error) }
+      }
+    } else {
+      switch (__pyx_nargs) {
         case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLDOJISTAR", 1, 4, 4, 2); __PYX_ERR(3, 1159, __pyx_L3_error)
-        }
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 476, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLDOJISTAR", 1, 4, 4, 3); __PYX_ERR(3, 1159, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_CDLDOJISTAR") < 0)) __PYX_ERR(3, 1159, __pyx_L3_error)
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 476, __pyx_L3_error)
+        break;
+        default: goto __pyx_L5_argtuple_error;
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
-      goto __pyx_L5_argtuple_error;
+    }
+    __pyx_v_real = ((PyArrayObject *)values[0]);
+    if (values[1]) {
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 478, __pyx_L3_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);
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
     }
-    __pyx_v_open = ((PyArrayObject *)values[0]);
-    __pyx_v_high = ((PyArrayObject *)values[1]);
-    __pyx_v_low = ((PyArrayObject *)values[2]);
-    __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_CDLDOJISTAR", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 1159, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_AVGDEV", 0, 1, 2, __pyx_nargs); __PYX_ERR(5, 476, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLDOJISTAR", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_AVGDEV", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 1159, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 1159, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 1159, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 1159, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_424stream_CDLDOJISTAR(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 478, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_392stream_AVGDEV(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_424stream_CDLDOJISTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_392stream_AVGDEV(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
-  double *__pyx_v_open_data;
-  double *__pyx_v_high_data;
-  double *__pyx_v_low_data;
-  double *__pyx_v_close_data;
+  double *__pyx_v_real_data;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  int __pyx_v_outinteger;
+  double __pyx_v_outreal;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  npy_intp __pyx_t_2;
-  __Pyx_RefNannySetupContext("stream_CDLDOJISTAR", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_open);
-  __Pyx_INCREF((PyObject *)__pyx_v_high);
-  __Pyx_INCREF((PyObject *)__pyx_v_low);
-  __Pyx_INCREF((PyObject *)__pyx_v_close);
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1179, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_v_open_data = ((double *)__pyx_v_open->data);
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1181, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_v_high_data = ((double *)__pyx_v_high->data);
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1183, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_v_low_data = ((double *)__pyx_v_low->data);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_AVGDEV", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1185, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 497, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_close_data = ((double *)__pyx_v_close->data);
+  __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real));
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(3, 1187, __pyx_L1_error)
-  __pyx_v_length = __pyx_t_2;
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
-  __pyx_v_outinteger = 0;
+  __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
 
-  __pyx_v_retCode = TA_CDLDOJISTAR((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
+  __pyx_v_retCode = TA_AVGDEV((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLDOJISTAR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1190, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_AVGDEV, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 502, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1191, __pyx_L1_error)
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 503, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -43945,13 +53388,10 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_424stream_CDLDOJISTAR(CYTHON_UNUSED Py
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLDOJISTAR", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_AVGDEV", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_open);
-  __Pyx_XDECREF((PyObject *)__pyx_v_high);
-  __Pyx_XDECREF((PyObject *)__pyx_v_low);
-  __Pyx_XDECREF((PyObject *)__pyx_v_close);
+  __Pyx_XDECREF((PyObject *)__pyx_v_real);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -43959,175 +53399,235 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_424stream_CDLDOJISTAR(CYTHON_UNUSED Py
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_427stream_CDLDRAGONFLYDOJI(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_426stream_CDLDRAGONFLYDOJI[] = " CDLDRAGONFLYDOJI(open, high, low, close)\n\n    Dragonfly Doji (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_427stream_CDLDRAGONFLYDOJI = {"stream_CDLDRAGONFLYDOJI", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_427stream_CDLDRAGONFLYDOJI, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_426stream_CDLDRAGONFLYDOJI};
-static PyObject *__pyx_pw_5talib_7_ta_lib_427stream_CDLDRAGONFLYDOJI(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_open = 0;
-  PyArrayObject *__pyx_v_high = 0;
-  PyArrayObject *__pyx_v_low = 0;
-  PyArrayObject *__pyx_v_close = 0;
+static PyObject *__pyx_pw_5talib_7_ta_lib_395stream_BBANDS(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_394stream_BBANDS, "stream_BBANDS(ndarray real, int timeperiod=-0x80000000, double nbdevup=-4e37, double nbdevdn=-4e37, int matype=0)\n\nBBANDS(real[, timeperiod=?, nbdevup=?, nbdevdn=?, matype=?])\n\nBollinger Bands (Overlap Studies)\n\nInputs:\n    real: (any ndarray)\nParameters:\n    timeperiod: 5\n    nbdevup: 2.0\n    nbdevdn: 2.0\n    matype: 0 (Simple Moving Average)\nOutputs:\n    upperband\n    middleband\n    lowerband");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_395stream_BBANDS = {"stream_BBANDS", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_395stream_BBANDS, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_394stream_BBANDS};
+static PyObject *__pyx_pw_5talib_7_ta_lib_395stream_BBANDS(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_real = 0;
+  int __pyx_v_timeperiod;
+  double __pyx_v_nbdevup;
+  double __pyx_v_nbdevdn;
+  int __pyx_v_matype;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[5] = {0,0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_CDLDRAGONFLYDOJI (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_BBANDS (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,&__pyx_mstate_global->__pyx_n_u_nbdevup,&__pyx_mstate_global->__pyx_n_u_nbdevdn,&__pyx_mstate_global->__pyx_n_u_matype,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 505, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  5:
+        values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(5, 505, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 505, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 505, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 505, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 505, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_BBANDS", 0) < (0)) __PYX_ERR(5, 505, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_BBANDS", 0, 1, 5, i); __PYX_ERR(5, 505, __pyx_L3_error) }
+      }
+    } else {
+      switch (__pyx_nargs) {
+        case  5:
+        values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(5, 505, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLDRAGONFLYDOJI", 1, 4, 4, 1); __PYX_ERR(3, 1195, __pyx_L3_error)
-        }
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 505, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 505, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLDRAGONFLYDOJI", 1, 4, 4, 2); __PYX_ERR(3, 1195, __pyx_L3_error)
-        }
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 505, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLDRAGONFLYDOJI", 1, 4, 4, 3); __PYX_ERR(3, 1195, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_CDLDRAGONFLYDOJI") < 0)) __PYX_ERR(3, 1195, __pyx_L3_error)
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 505, __pyx_L3_error)
+        break;
+        default: goto __pyx_L5_argtuple_error;
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
-      goto __pyx_L5_argtuple_error;
+    }
+    __pyx_v_real = ((PyArrayObject *)values[0]);
+    if (values[1]) {
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 507, __pyx_L3_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);
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
+    }
+    if (values[2]) {
+      __pyx_v_nbdevup = __Pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_nbdevup == (double)-1) && PyErr_Occurred())) __PYX_ERR(5, 507, __pyx_L3_error)
+    } else {
+      __pyx_v_nbdevup = ((double)((double)-4e37));
+    }
+    if (values[3]) {
+      __pyx_v_nbdevdn = __Pyx_PyFloat_AsDouble(values[3]); if (unlikely((__pyx_v_nbdevdn == (double)-1) && PyErr_Occurred())) __PYX_ERR(5, 507, __pyx_L3_error)
+    } else {
+      __pyx_v_nbdevdn = ((double)((double)-4e37));
+    }
+    if (values[4]) {
+      __pyx_v_matype = __Pyx_PyLong_As_int(values[4]); if (unlikely((__pyx_v_matype == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 507, __pyx_L3_error)
+    } else {
+      __pyx_v_matype = ((int)((int)0));
     }
-    __pyx_v_open = ((PyArrayObject *)values[0]);
-    __pyx_v_high = ((PyArrayObject *)values[1]);
-    __pyx_v_low = ((PyArrayObject *)values[2]);
-    __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_CDLDRAGONFLYDOJI", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 1195, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_BBANDS", 0, 1, 5, __pyx_nargs); __PYX_ERR(5, 505, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLDRAGONFLYDOJI", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __Pyx_RefNannyFinishContext();
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_BBANDS", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 1195, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 1195, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 1195, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 1195, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_426stream_CDLDRAGONFLYDOJI(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 507, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_394stream_BBANDS(__pyx_self, __pyx_v_real, __pyx_v_timeperiod, __pyx_v_nbdevup, __pyx_v_nbdevdn, __pyx_v_matype);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_426stream_CDLDRAGONFLYDOJI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_394stream_BBANDS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod, double __pyx_v_nbdevup, double __pyx_v_nbdevdn, int __pyx_v_matype) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
-  double *__pyx_v_open_data;
-  double *__pyx_v_high_data;
-  double *__pyx_v_low_data;
-  double *__pyx_v_close_data;
+  double *__pyx_v_real_data;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  int __pyx_v_outinteger;
+  double __pyx_v_outrealupperband;
+  double __pyx_v_outrealmiddleband;
+  double __pyx_v_outreallowerband;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  npy_intp __pyx_t_2;
-  __Pyx_RefNannySetupContext("stream_CDLDRAGONFLYDOJI", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_open);
-  __Pyx_INCREF((PyObject *)__pyx_v_high);
-  __Pyx_INCREF((PyObject *)__pyx_v_low);
-  __Pyx_INCREF((PyObject *)__pyx_v_close);
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1215, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_v_open_data = ((double *)__pyx_v_open->data);
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1217, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_v_high_data = ((double *)__pyx_v_high->data);
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_BBANDS", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1219, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 533, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_low_data = ((double *)__pyx_v_low->data);
+  __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1221, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
-  __pyx_v_close_data = ((double *)__pyx_v_close->data);
+  __pyx_v_outrealupperband = __pyx_v_5talib_7_ta_lib_NaN;
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(3, 1223, __pyx_L1_error)
-  __pyx_v_length = __pyx_t_2;
+  __pyx_v_outrealmiddleband = __pyx_v_5talib_7_ta_lib_NaN;
 
-  __pyx_v_outinteger = 0;
+  __pyx_v_outreallowerband = __pyx_v_5talib_7_ta_lib_NaN;
 
-  __pyx_v_retCode = TA_CDLDRAGONFLYDOJI((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
+  __pyx_v_retCode = TA_BBANDS((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, __pyx_v_nbdevup, __pyx_v_nbdevdn, __pyx_v_matype, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outrealupperband), (&__pyx_v_outrealmiddleband), (&__pyx_v_outreallowerband));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLDRAGONFLYDOJI, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1226, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_BBANDS, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 540, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1227, __pyx_L1_error)
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outrealupperband); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 541, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_r = __pyx_t_1;
+  __pyx_t_2 = PyFloat_FromDouble(__pyx_v_outrealmiddleband); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 541, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = PyFloat_FromDouble(__pyx_v_outreallowerband); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 541, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 541, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_GIVEREF(__pyx_t_1);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1) != (0)) __PYX_ERR(5, 541, __pyx_L1_error);
+  __Pyx_GIVEREF(__pyx_t_2);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_2) != (0)) __PYX_ERR(5, 541, __pyx_L1_error);
+  __Pyx_GIVEREF(__pyx_t_3);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_t_3) != (0)) __PYX_ERR(5, 541, __pyx_L1_error);
   __pyx_t_1 = 0;
+  __pyx_t_2 = 0;
+  __pyx_t_3 = 0;
+  __pyx_r = __pyx_t_4;
+  __pyx_t_4 = 0;
   goto __pyx_L0;
 
 
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLDRAGONFLYDOJI", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_AddTraceback("talib._ta_lib.stream_BBANDS", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_open);
-  __Pyx_XDECREF((PyObject *)__pyx_v_high);
-  __Pyx_XDECREF((PyObject *)__pyx_v_low);
-  __Pyx_XDECREF((PyObject *)__pyx_v_close);
+  __Pyx_XDECREF((PyObject *)__pyx_v_real);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -44135,159 +53635,173 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_426stream_CDLDRAGONFLYDOJI(CYTHON_UNUS
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_429stream_CDLENGULFING(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_428stream_CDLENGULFING[] = " CDLENGULFING(open, high, low, close)\n\n    Engulfing Pattern (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_429stream_CDLENGULFING = {"stream_CDLENGULFING", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_429stream_CDLENGULFING, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_428stream_CDLENGULFING};
-static PyObject *__pyx_pw_5talib_7_ta_lib_429stream_CDLENGULFING(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_open = 0;
-  PyArrayObject *__pyx_v_high = 0;
-  PyArrayObject *__pyx_v_low = 0;
-  PyArrayObject *__pyx_v_close = 0;
+static PyObject *__pyx_pw_5talib_7_ta_lib_397stream_BETA(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_396stream_BETA, "stream_BETA(ndarray real0, ndarray real1, int timeperiod=-0x80000000)\n\nBETA(real0, real1[, timeperiod=?])\n\nBeta (Statistic Functions)\n\nInputs:\n    real0: (any ndarray)\n    real1: (any ndarray)\nParameters:\n    timeperiod: 5\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_397stream_BETA = {"stream_BETA", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_397stream_BETA, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_396stream_BETA};
+static PyObject *__pyx_pw_5talib_7_ta_lib_397stream_BETA(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_real0 = 0;
+  PyArrayObject *__pyx_v_real1 = 0;
+  int __pyx_v_timeperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[3] = {0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_CDLENGULFING (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_BETA (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real0,&__pyx_mstate_global->__pyx_n_u_real1,&__pyx_mstate_global->__pyx_n_u_timeperiod,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 543, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 543, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 543, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 543, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLENGULFING", 1, 4, 4, 1); __PYX_ERR(3, 1231, __pyx_L3_error)
-        }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_BETA", 0) < (0)) __PYX_ERR(5, 543, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_BETA", 0, 2, 3, i); __PYX_ERR(5, 543, __pyx_L3_error) }
+      }
+    } else {
+      switch (__pyx_nargs) {
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 543, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLENGULFING", 1, 4, 4, 2); __PYX_ERR(3, 1231, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLENGULFING", 1, 4, 4, 3); __PYX_ERR(3, 1231, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_CDLENGULFING") < 0)) __PYX_ERR(3, 1231, __pyx_L3_error)
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 543, __pyx_L3_error)
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 543, __pyx_L3_error)
+        break;
+        default: goto __pyx_L5_argtuple_error;
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
-      goto __pyx_L5_argtuple_error;
+    }
+    __pyx_v_real0 = ((PyArrayObject *)values[0]);
+    __pyx_v_real1 = ((PyArrayObject *)values[1]);
+    if (values[2]) {
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[2]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 545, __pyx_L3_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);
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
     }
-    __pyx_v_open = ((PyArrayObject *)values[0]);
-    __pyx_v_high = ((PyArrayObject *)values[1]);
-    __pyx_v_low = ((PyArrayObject *)values[2]);
-    __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_CDLENGULFING", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 1231, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_BETA", 0, 2, 3, __pyx_nargs); __PYX_ERR(5, 543, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLENGULFING", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_BETA", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 1231, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 1231, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 1231, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 1231, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_428stream_CDLENGULFING(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real0), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real0", 0))) __PYX_ERR(5, 545, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real1), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real1", 0))) __PYX_ERR(5, 545, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_396stream_BETA(__pyx_self, __pyx_v_real0, __pyx_v_real1, __pyx_v_timeperiod);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_428stream_CDLENGULFING(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_396stream_BETA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real0, PyArrayObject *__pyx_v_real1, int __pyx_v_timeperiod) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
-  double *__pyx_v_open_data;
-  double *__pyx_v_high_data;
-  double *__pyx_v_low_data;
-  double *__pyx_v_close_data;
+  double *__pyx_v_real0_data;
+  double *__pyx_v_real1_data;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  int __pyx_v_outinteger;
+  double __pyx_v_outreal;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
-  __Pyx_RefNannySetupContext("stream_CDLENGULFING", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_open);
-  __Pyx_INCREF((PyObject *)__pyx_v_high);
-  __Pyx_INCREF((PyObject *)__pyx_v_low);
-  __Pyx_INCREF((PyObject *)__pyx_v_close);
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1251, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_v_open_data = ((double *)__pyx_v_open->data);
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1253, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_v_high_data = ((double *)__pyx_v_high->data);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_BETA", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_real0);
+  __Pyx_INCREF((PyObject *)__pyx_v_real1);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1255, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 566, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_real0, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_low_data = ((double *)__pyx_v_low->data);
+  __pyx_v_real0_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real0));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1257, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 568, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_real1, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_close_data = ((double *)__pyx_v_close->data);
+  __pyx_v_real1_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real1));
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(3, 1259, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_real0, __pyx_v_real1); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 570, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
-  __pyx_v_outinteger = 0;
+  __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
 
-  __pyx_v_retCode = TA_CDLENGULFING((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
+  __pyx_v_retCode = TA_BETA((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real0_data, __pyx_v_real1_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLENGULFING, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1262, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_BETA, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 573, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1263, __pyx_L1_error)
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 574, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -44297,13 +53811,11 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_428stream_CDLENGULFING(CYTHON_UNUSED P
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLENGULFING", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_BETA", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_open);
-  __Pyx_XDECREF((PyObject *)__pyx_v_high);
-  __Pyx_XDECREF((PyObject *)__pyx_v_low);
-  __Pyx_XDECREF((PyObject *)__pyx_v_close);
+  __Pyx_XDECREF((PyObject *)__pyx_v_real0);
+  __Pyx_XDECREF((PyObject *)__pyx_v_real1);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -44311,117 +53823,129 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_428stream_CDLENGULFING(CYTHON_UNUSED P
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_431stream_CDLEVENINGDOJISTAR(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_430stream_CDLEVENINGDOJISTAR[] = " CDLEVENINGDOJISTAR(open, high, low, close[, penetration=?])\n\n    Evening Doji Star (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Parameters:\n        penetration: 0.3\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_431stream_CDLEVENINGDOJISTAR = {"stream_CDLEVENINGDOJISTAR", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_431stream_CDLEVENINGDOJISTAR, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_430stream_CDLEVENINGDOJISTAR};
-static PyObject *__pyx_pw_5talib_7_ta_lib_431stream_CDLEVENINGDOJISTAR(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_399stream_BOP(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_398stream_BOP, "stream_BOP(ndarray open, ndarray high, ndarray low, ndarray close)\n\nBOP(open, high, low, close)\n\nBalance Of Power (Momentum Indicators)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_399stream_BOP = {"stream_BOP", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_399stream_BOP, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_398stream_BOP};
+static PyObject *__pyx_pw_5talib_7_ta_lib_399stream_BOP(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_open = 0;
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
-  double __pyx_v_penetration;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_CDLEVENINGDOJISTAR (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_BOP (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,&__pyx_n_s_penetration,0};
-    PyObject* values[5] = {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  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
-        CYTHON_FALLTHROUGH;
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 576, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 576, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 576, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 576, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 576, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLEVENINGDOJISTAR", 0, 4, 5, 1); __PYX_ERR(3, 1267, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLEVENINGDOJISTAR", 0, 4, 5, 2); __PYX_ERR(3, 1267, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLEVENINGDOJISTAR", 0, 4, 5, 3); __PYX_ERR(3, 1267, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  4:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_penetration);
-          if (value) { values[4] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_CDLEVENINGDOJISTAR") < 0)) __PYX_ERR(3, 1267, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_BOP", 0) < (0)) __PYX_ERR(5, 576, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_BOP", 1, 4, 4, i); __PYX_ERR(5, 576, __pyx_L3_error) }
       }
+    } else if (unlikely(__pyx_nargs != 4)) {
+      goto __pyx_L5_argtuple_error;
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
-        CYTHON_FALLTHROUGH;
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-        break;
-        default: goto __pyx_L5_argtuple_error;
-      }
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 576, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 576, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 576, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 576, __pyx_L3_error)
     }
     __pyx_v_open = ((PyArrayObject *)values[0]);
     __pyx_v_high = ((PyArrayObject *)values[1]);
     __pyx_v_low = ((PyArrayObject *)values[2]);
     __pyx_v_close = ((PyArrayObject *)values[3]);
-    if (values[4]) {
-      __pyx_v_penetration = __pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_penetration == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 1267, __pyx_L3_error)
-    } else {
-      __pyx_v_penetration = ((double)0.3);
-    }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_CDLEVENINGDOJISTAR", 0, 4, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 1267, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_BOP", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 576, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLEVENINGDOJISTAR", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_BOP", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 1267, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 1267, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 1267, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 1267, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_430stream_CDLEVENINGDOJISTAR(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_penetration);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 578, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 578, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 578, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 578, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_398stream_BOP(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_430stream_CDLEVENINGDOJISTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_398stream_BOP(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
   double *__pyx_v_open_data;
@@ -44430,58 +53954,61 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_430stream_CDLEVENINGDOJISTAR(CYTHON_UN
   double *__pyx_v_close_data;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  int __pyx_v_outinteger;
+  double __pyx_v_outreal;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
-  __Pyx_RefNannySetupContext("stream_CDLEVENINGDOJISTAR", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_BOP", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_open);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1289, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 598, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_open_data = ((double *)__pyx_v_open->data);
+  __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1291, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 600, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_high_data = ((double *)__pyx_v_high->data);
+  __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1293, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 602, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_low_data = ((double *)__pyx_v_low->data);
+  __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1295, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 604, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_close_data = ((double *)__pyx_v_close->data);
+  __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close));
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(3, 1297, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 606, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
-  __pyx_v_outinteger = 0;
+  __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
 
-  __pyx_v_retCode = TA_CDLEVENINGDOJISTAR((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, __pyx_v_penetration, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
+  __pyx_v_retCode = TA_BOP((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLEVENINGDOJISTAR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1300, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_BOP, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 609, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1301, __pyx_L1_error)
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 610, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -44491,7 +54018,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_430stream_CDLEVENINGDOJISTAR(CYTHON_UN
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLEVENINGDOJISTAR", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_BOP", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_open);
@@ -44505,177 +54032,191 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_430stream_CDLEVENINGDOJISTAR(CYTHON_UN
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_433stream_CDLEVENINGSTAR(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_432stream_CDLEVENINGSTAR[] = " CDLEVENINGSTAR(open, high, low, close[, penetration=?])\n\n    Evening Star (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Parameters:\n        penetration: 0.3\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_433stream_CDLEVENINGSTAR = {"stream_CDLEVENINGSTAR", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_433stream_CDLEVENINGSTAR, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_432stream_CDLEVENINGSTAR};
-static PyObject *__pyx_pw_5talib_7_ta_lib_433stream_CDLEVENINGSTAR(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_open = 0;
+static PyObject *__pyx_pw_5talib_7_ta_lib_401stream_CCI(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_400stream_CCI, "stream_CCI(ndarray high, ndarray low, ndarray close, int timeperiod=-0x80000000)\n\nCCI(high, low, close[, timeperiod=?])\n\nCommodity Channel Index (Momentum Indicators)\n\nInputs:\n    prices: ['high', 'low', 'close']\nParameters:\n    timeperiod: 14\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_401stream_CCI = {"stream_CCI", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_401stream_CCI, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_400stream_CCI};
+static PyObject *__pyx_pw_5talib_7_ta_lib_401stream_CCI(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
-  double __pyx_v_penetration;
+  int __pyx_v_timeperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_CDLEVENINGSTAR (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_CCI (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,&__pyx_n_s_penetration,0};
-    PyObject* values[5] = {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  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
-        CYTHON_FALLTHROUGH;
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,&__pyx_mstate_global->__pyx_n_u_timeperiod,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 612, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 612, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 612, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 612, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 612, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLEVENINGSTAR", 0, 4, 5, 1); __PYX_ERR(3, 1305, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLEVENINGSTAR", 0, 4, 5, 2); __PYX_ERR(3, 1305, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLEVENINGSTAR", 0, 4, 5, 3); __PYX_ERR(3, 1305, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  4:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_penetration);
-          if (value) { values[4] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_CDLEVENINGSTAR") < 0)) __PYX_ERR(3, 1305, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CCI", 0) < (0)) __PYX_ERR(5, 612, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 3; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CCI", 0, 3, 4, i); __PYX_ERR(5, 612, __pyx_L3_error) }
       }
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 612, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 612, __pyx_L3_error)
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 612, __pyx_L3_error)
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 612, __pyx_L3_error)
         break;
         default: goto __pyx_L5_argtuple_error;
       }
     }
-    __pyx_v_open = ((PyArrayObject *)values[0]);
-    __pyx_v_high = ((PyArrayObject *)values[1]);
-    __pyx_v_low = ((PyArrayObject *)values[2]);
-    __pyx_v_close = ((PyArrayObject *)values[3]);
-    if (values[4]) {
-      __pyx_v_penetration = __pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_penetration == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 1305, __pyx_L3_error)
+    __pyx_v_high = ((PyArrayObject *)values[0]);
+    __pyx_v_low = ((PyArrayObject *)values[1]);
+    __pyx_v_close = ((PyArrayObject *)values[2]);
+    if (values[3]) {
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[3]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 614, __pyx_L3_error)
     } else {
-      __pyx_v_penetration = ((double)0.3);
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
     }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_CDLEVENINGSTAR", 0, 4, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 1305, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_CCI", 0, 3, 4, __pyx_nargs); __PYX_ERR(5, 612, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLEVENINGSTAR", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_CCI", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 1305, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 1305, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 1305, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 1305, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_432stream_CDLEVENINGSTAR(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_penetration);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 614, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 614, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 614, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_400stream_CCI(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_timeperiod);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_432stream_CDLEVENINGSTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_400stream_CCI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
-  double *__pyx_v_open_data;
   double *__pyx_v_high_data;
   double *__pyx_v_low_data;
   double *__pyx_v_close_data;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  int __pyx_v_outinteger;
+  double __pyx_v_outreal;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
-  __Pyx_RefNannySetupContext("stream_CDLEVENINGSTAR", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_open);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_CCI", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1327, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_v_open_data = ((double *)__pyx_v_open->data);
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1329, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 635, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_high_data = ((double *)__pyx_v_high->data);
+  __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1331, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 637, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_low_data = ((double *)__pyx_v_low->data);
+  __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1333, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 639, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_close_data = ((double *)__pyx_v_close->data);
+  __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close));
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(3, 1335, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 641, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
-  __pyx_v_outinteger = 0;
+  __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
 
-  __pyx_v_retCode = TA_CDLEVENINGSTAR((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, __pyx_v_penetration, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
+  __pyx_v_retCode = TA_CCI((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLEVENINGSTAR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1338, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CCI, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 644, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1339, __pyx_L1_error)
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 645, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -44685,10 +54226,9 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_432stream_CDLEVENINGSTAR(CYTHON_UNUSED
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLEVENINGSTAR", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_CCI", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_open);
   __Pyx_XDECREF((PyObject *)__pyx_v_high);
   __Pyx_XDECREF((PyObject *)__pyx_v_low);
   __Pyx_XDECREF((PyObject *)__pyx_v_close);
@@ -44699,99 +54239,129 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_432stream_CDLEVENINGSTAR(CYTHON_UNUSED
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_435stream_CDLGAPSIDESIDEWHITE(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_434stream_CDLGAPSIDESIDEWHITE[] = " CDLGAPSIDESIDEWHITE(open, high, low, close)\n\n    Up/Down-gap side-by-side white lines (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_435stream_CDLGAPSIDESIDEWHITE = {"stream_CDLGAPSIDESIDEWHITE", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_435stream_CDLGAPSIDESIDEWHITE, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_434stream_CDLGAPSIDESIDEWHITE};
-static PyObject *__pyx_pw_5talib_7_ta_lib_435stream_CDLGAPSIDESIDEWHITE(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_403stream_CDL2CROWS(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_402stream_CDL2CROWS, "stream_CDL2CROWS(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDL2CROWS(open, high, low, close)\n\nTwo Crows (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_403stream_CDL2CROWS = {"stream_CDL2CROWS", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_403stream_CDL2CROWS, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_402stream_CDL2CROWS};
+static PyObject *__pyx_pw_5talib_7_ta_lib_403stream_CDL2CROWS(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_open = 0;
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_CDLGAPSIDESIDEWHITE (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_CDL2CROWS (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 647, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 647, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 647, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 647, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 647, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLGAPSIDESIDEWHITE", 1, 4, 4, 1); __PYX_ERR(3, 1343, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLGAPSIDESIDEWHITE", 1, 4, 4, 2); __PYX_ERR(3, 1343, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLGAPSIDESIDEWHITE", 1, 4, 4, 3); __PYX_ERR(3, 1343, __pyx_L3_error)
-        }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDL2CROWS", 0) < (0)) __PYX_ERR(5, 647, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDL2CROWS", 1, 4, 4, i); __PYX_ERR(5, 647, __pyx_L3_error) }
       }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_CDLGAPSIDESIDEWHITE") < 0)) __PYX_ERR(3, 1343, __pyx_L3_error)
-      }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
+    } else if (unlikely(__pyx_nargs != 4)) {
       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[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 647, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 647, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 647, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 647, __pyx_L3_error)
     }
     __pyx_v_open = ((PyArrayObject *)values[0]);
     __pyx_v_high = ((PyArrayObject *)values[1]);
     __pyx_v_low = ((PyArrayObject *)values[2]);
     __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_CDLGAPSIDESIDEWHITE", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 1343, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_CDL2CROWS", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 647, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLGAPSIDESIDEWHITE", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDL2CROWS", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 1343, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 1343, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 1343, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 1343, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_434stream_CDLGAPSIDESIDEWHITE(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 649, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 649, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 649, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 649, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_402stream_CDL2CROWS(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_434stream_CDLGAPSIDESIDEWHITE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_402stream_CDL2CROWS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
   double *__pyx_v_open_data;
@@ -44805,53 +54375,56 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_434stream_CDLGAPSIDESIDEWHITE(CYTHON_U
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
-  __Pyx_RefNannySetupContext("stream_CDLGAPSIDESIDEWHITE", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_CDL2CROWS", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_open);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1363, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 669, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_open_data = ((double *)__pyx_v_open->data);
+  __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1365, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 671, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_high_data = ((double *)__pyx_v_high->data);
+  __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1367, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 673, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_low_data = ((double *)__pyx_v_low->data);
+  __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1369, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 675, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_close_data = ((double *)__pyx_v_close->data);
+  __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close));
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(3, 1371, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 677, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
   __pyx_v_outinteger = 0;
 
-  __pyx_v_retCode = TA_CDLGAPSIDESIDEWHITE((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
+  __pyx_v_retCode = TA_CDL2CROWS((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLGAPSIDESIDEWHITE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1374, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDL2CROWS, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 680, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1375, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 681, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -44861,7 +54434,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_434stream_CDLGAPSIDESIDEWHITE(CYTHON_U
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLGAPSIDESIDEWHITE", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDL2CROWS", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_open);
@@ -44875,99 +54448,129 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_434stream_CDLGAPSIDESIDEWHITE(CYTHON_U
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_437stream_CDLGRAVESTONEDOJI(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_436stream_CDLGRAVESTONEDOJI[] = " CDLGRAVESTONEDOJI(open, high, low, close)\n\n    Gravestone Doji (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_437stream_CDLGRAVESTONEDOJI = {"stream_CDLGRAVESTONEDOJI", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_437stream_CDLGRAVESTONEDOJI, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_436stream_CDLGRAVESTONEDOJI};
-static PyObject *__pyx_pw_5talib_7_ta_lib_437stream_CDLGRAVESTONEDOJI(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_405stream_CDL3BLACKCROWS(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_404stream_CDL3BLACKCROWS, "stream_CDL3BLACKCROWS(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDL3BLACKCROWS(open, high, low, close)\n\nThree Black Crows (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_405stream_CDL3BLACKCROWS = {"stream_CDL3BLACKCROWS", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_405stream_CDL3BLACKCROWS, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_404stream_CDL3BLACKCROWS};
+static PyObject *__pyx_pw_5talib_7_ta_lib_405stream_CDL3BLACKCROWS(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_open = 0;
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_CDLGRAVESTONEDOJI (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_CDL3BLACKCROWS (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 683, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 683, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 683, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 683, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 683, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLGRAVESTONEDOJI", 1, 4, 4, 1); __PYX_ERR(3, 1379, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLGRAVESTONEDOJI", 1, 4, 4, 2); __PYX_ERR(3, 1379, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLGRAVESTONEDOJI", 1, 4, 4, 3); __PYX_ERR(3, 1379, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_CDLGRAVESTONEDOJI") < 0)) __PYX_ERR(3, 1379, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDL3BLACKCROWS", 0) < (0)) __PYX_ERR(5, 683, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDL3BLACKCROWS", 1, 4, 4, i); __PYX_ERR(5, 683, __pyx_L3_error) }
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
+    } else if (unlikely(__pyx_nargs != 4)) {
       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[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 683, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 683, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 683, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 683, __pyx_L3_error)
     }
     __pyx_v_open = ((PyArrayObject *)values[0]);
     __pyx_v_high = ((PyArrayObject *)values[1]);
     __pyx_v_low = ((PyArrayObject *)values[2]);
     __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_CDLGRAVESTONEDOJI", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 1379, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_CDL3BLACKCROWS", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 683, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLGRAVESTONEDOJI", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDL3BLACKCROWS", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 1379, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 1379, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 1379, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 1379, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_436stream_CDLGRAVESTONEDOJI(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 685, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 685, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 685, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 685, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_404stream_CDL3BLACKCROWS(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_436stream_CDLGRAVESTONEDOJI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_404stream_CDL3BLACKCROWS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
   double *__pyx_v_open_data;
@@ -44981,53 +54584,56 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_436stream_CDLGRAVESTONEDOJI(CYTHON_UNU
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
-  __Pyx_RefNannySetupContext("stream_CDLGRAVESTONEDOJI", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_CDL3BLACKCROWS", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_open);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1399, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 705, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_open_data = ((double *)__pyx_v_open->data);
+  __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1401, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 707, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_high_data = ((double *)__pyx_v_high->data);
+  __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1403, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 709, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_low_data = ((double *)__pyx_v_low->data);
+  __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1405, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 711, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_close_data = ((double *)__pyx_v_close->data);
+  __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close));
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(3, 1407, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 713, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
   __pyx_v_outinteger = 0;
 
-  __pyx_v_retCode = TA_CDLGRAVESTONEDOJI((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
+  __pyx_v_retCode = TA_CDL3BLACKCROWS((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLGRAVESTONEDOJI, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1410, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDL3BLACKCROWS, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 716, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1411, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 717, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -45037,7 +54643,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_436stream_CDLGRAVESTONEDOJI(CYTHON_UNU
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLGRAVESTONEDOJI", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDL3BLACKCROWS", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_open);
@@ -45051,99 +54657,129 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_436stream_CDLGRAVESTONEDOJI(CYTHON_UNU
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_439stream_CDLHAMMER(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_438stream_CDLHAMMER[] = " CDLHAMMER(open, high, low, close)\n\n    Hammer (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_439stream_CDLHAMMER = {"stream_CDLHAMMER", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_439stream_CDLHAMMER, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_438stream_CDLHAMMER};
-static PyObject *__pyx_pw_5talib_7_ta_lib_439stream_CDLHAMMER(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_407stream_CDL3INSIDE(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_406stream_CDL3INSIDE, "stream_CDL3INSIDE(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDL3INSIDE(open, high, low, close)\n\nThree Inside Up/Down (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_407stream_CDL3INSIDE = {"stream_CDL3INSIDE", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_407stream_CDL3INSIDE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_406stream_CDL3INSIDE};
+static PyObject *__pyx_pw_5talib_7_ta_lib_407stream_CDL3INSIDE(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_open = 0;
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_CDLHAMMER (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_CDL3INSIDE (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 719, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 719, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 719, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 719, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 719, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLHAMMER", 1, 4, 4, 1); __PYX_ERR(3, 1415, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLHAMMER", 1, 4, 4, 2); __PYX_ERR(3, 1415, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLHAMMER", 1, 4, 4, 3); __PYX_ERR(3, 1415, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_CDLHAMMER") < 0)) __PYX_ERR(3, 1415, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDL3INSIDE", 0) < (0)) __PYX_ERR(5, 719, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDL3INSIDE", 1, 4, 4, i); __PYX_ERR(5, 719, __pyx_L3_error) }
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
+    } else if (unlikely(__pyx_nargs != 4)) {
       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[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 719, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 719, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 719, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 719, __pyx_L3_error)
     }
     __pyx_v_open = ((PyArrayObject *)values[0]);
     __pyx_v_high = ((PyArrayObject *)values[1]);
     __pyx_v_low = ((PyArrayObject *)values[2]);
     __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_CDLHAMMER", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 1415, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_CDL3INSIDE", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 719, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLHAMMER", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDL3INSIDE", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 1415, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 1415, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 1415, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 1415, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_438stream_CDLHAMMER(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 721, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 721, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 721, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 721, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_406stream_CDL3INSIDE(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_438stream_CDLHAMMER(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_406stream_CDL3INSIDE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
   double *__pyx_v_open_data;
@@ -45157,53 +54793,56 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_438stream_CDLHAMMER(CYTHON_UNUSED PyOb
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
-  __Pyx_RefNannySetupContext("stream_CDLHAMMER", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_CDL3INSIDE", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_open);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1435, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 741, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_open_data = ((double *)__pyx_v_open->data);
+  __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1437, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 743, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_high_data = ((double *)__pyx_v_high->data);
+  __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1439, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 745, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_low_data = ((double *)__pyx_v_low->data);
+  __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1441, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 747, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_close_data = ((double *)__pyx_v_close->data);
+  __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close));
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(3, 1443, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 749, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
   __pyx_v_outinteger = 0;
 
-  __pyx_v_retCode = TA_CDLHAMMER((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
+  __pyx_v_retCode = TA_CDL3INSIDE((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLHAMMER, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1446, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDL3INSIDE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 752, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1447, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 753, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -45213,7 +54852,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_438stream_CDLHAMMER(CYTHON_UNUSED PyOb
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLHAMMER", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDL3INSIDE", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_open);
@@ -45227,99 +54866,129 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_438stream_CDLHAMMER(CYTHON_UNUSED PyOb
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_441stream_CDLHANGINGMAN(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_440stream_CDLHANGINGMAN[] = " CDLHANGINGMAN(open, high, low, close)\n\n    Hanging Man (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_441stream_CDLHANGINGMAN = {"stream_CDLHANGINGMAN", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_441stream_CDLHANGINGMAN, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_440stream_CDLHANGINGMAN};
-static PyObject *__pyx_pw_5talib_7_ta_lib_441stream_CDLHANGINGMAN(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_409stream_CDL3LINESTRIKE(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_408stream_CDL3LINESTRIKE, "stream_CDL3LINESTRIKE(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDL3LINESTRIKE(open, high, low, close)\n\nThree-Line Strike  (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_409stream_CDL3LINESTRIKE = {"stream_CDL3LINESTRIKE", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_409stream_CDL3LINESTRIKE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_408stream_CDL3LINESTRIKE};
+static PyObject *__pyx_pw_5talib_7_ta_lib_409stream_CDL3LINESTRIKE(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_open = 0;
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_CDLHANGINGMAN (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_CDL3LINESTRIKE (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 755, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 755, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 755, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 755, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 755, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLHANGINGMAN", 1, 4, 4, 1); __PYX_ERR(3, 1451, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLHANGINGMAN", 1, 4, 4, 2); __PYX_ERR(3, 1451, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLHANGINGMAN", 1, 4, 4, 3); __PYX_ERR(3, 1451, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_CDLHANGINGMAN") < 0)) __PYX_ERR(3, 1451, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDL3LINESTRIKE", 0) < (0)) __PYX_ERR(5, 755, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDL3LINESTRIKE", 1, 4, 4, i); __PYX_ERR(5, 755, __pyx_L3_error) }
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
+    } else if (unlikely(__pyx_nargs != 4)) {
       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[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 755, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 755, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 755, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 755, __pyx_L3_error)
     }
     __pyx_v_open = ((PyArrayObject *)values[0]);
     __pyx_v_high = ((PyArrayObject *)values[1]);
     __pyx_v_low = ((PyArrayObject *)values[2]);
     __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_CDLHANGINGMAN", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 1451, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_CDL3LINESTRIKE", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 755, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLHANGINGMAN", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDL3LINESTRIKE", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 1451, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 1451, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 1451, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 1451, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_440stream_CDLHANGINGMAN(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 757, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 757, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 757, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 757, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_408stream_CDL3LINESTRIKE(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_440stream_CDLHANGINGMAN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_408stream_CDL3LINESTRIKE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
   double *__pyx_v_open_data;
@@ -45333,53 +55002,56 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_440stream_CDLHANGINGMAN(CYTHON_UNUSED
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
-  __Pyx_RefNannySetupContext("stream_CDLHANGINGMAN", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_CDL3LINESTRIKE", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_open);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1471, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 777, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_open_data = ((double *)__pyx_v_open->data);
+  __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1473, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 779, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_high_data = ((double *)__pyx_v_high->data);
+  __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1475, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 781, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_low_data = ((double *)__pyx_v_low->data);
+  __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1477, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 783, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_close_data = ((double *)__pyx_v_close->data);
+  __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close));
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(3, 1479, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 785, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
   __pyx_v_outinteger = 0;
 
-  __pyx_v_retCode = TA_CDLHANGINGMAN((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
+  __pyx_v_retCode = TA_CDL3LINESTRIKE((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLHANGINGMAN, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1482, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDL3LINESTRIKE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 788, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1483, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 789, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -45389,7 +55061,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_440stream_CDLHANGINGMAN(CYTHON_UNUSED
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLHANGINGMAN", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDL3LINESTRIKE", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_open);
@@ -45403,99 +55075,129 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_440stream_CDLHANGINGMAN(CYTHON_UNUSED
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_443stream_CDLHARAMI(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_442stream_CDLHARAMI[] = " CDLHARAMI(open, high, low, close)\n\n    Harami Pattern (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_443stream_CDLHARAMI = {"stream_CDLHARAMI", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_443stream_CDLHARAMI, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_442stream_CDLHARAMI};
-static PyObject *__pyx_pw_5talib_7_ta_lib_443stream_CDLHARAMI(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_411stream_CDL3OUTSIDE(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_410stream_CDL3OUTSIDE, "stream_CDL3OUTSIDE(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDL3OUTSIDE(open, high, low, close)\n\nThree Outside Up/Down (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_411stream_CDL3OUTSIDE = {"stream_CDL3OUTSIDE", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_411stream_CDL3OUTSIDE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_410stream_CDL3OUTSIDE};
+static PyObject *__pyx_pw_5talib_7_ta_lib_411stream_CDL3OUTSIDE(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_open = 0;
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_CDLHARAMI (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_CDL3OUTSIDE (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 791, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 791, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 791, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 791, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 791, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLHARAMI", 1, 4, 4, 1); __PYX_ERR(3, 1487, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLHARAMI", 1, 4, 4, 2); __PYX_ERR(3, 1487, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLHARAMI", 1, 4, 4, 3); __PYX_ERR(3, 1487, __pyx_L3_error)
-        }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDL3OUTSIDE", 0) < (0)) __PYX_ERR(5, 791, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDL3OUTSIDE", 1, 4, 4, i); __PYX_ERR(5, 791, __pyx_L3_error) }
       }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_CDLHARAMI") < 0)) __PYX_ERR(3, 1487, __pyx_L3_error)
-      }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
+    } else if (unlikely(__pyx_nargs != 4)) {
       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[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 791, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 791, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 791, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 791, __pyx_L3_error)
     }
     __pyx_v_open = ((PyArrayObject *)values[0]);
     __pyx_v_high = ((PyArrayObject *)values[1]);
     __pyx_v_low = ((PyArrayObject *)values[2]);
     __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_CDLHARAMI", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 1487, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_CDL3OUTSIDE", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 791, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLHARAMI", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDL3OUTSIDE", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 1487, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 1487, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 1487, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 1487, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_442stream_CDLHARAMI(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 793, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 793, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 793, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 793, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_410stream_CDL3OUTSIDE(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_442stream_CDLHARAMI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_410stream_CDL3OUTSIDE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
   double *__pyx_v_open_data;
@@ -45509,53 +55211,56 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_442stream_CDLHARAMI(CYTHON_UNUSED PyOb
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
-  __Pyx_RefNannySetupContext("stream_CDLHARAMI", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_CDL3OUTSIDE", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_open);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1507, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 813, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_open_data = ((double *)__pyx_v_open->data);
+  __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1509, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 815, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_high_data = ((double *)__pyx_v_high->data);
+  __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1511, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 817, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_low_data = ((double *)__pyx_v_low->data);
+  __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1513, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 819, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_close_data = ((double *)__pyx_v_close->data);
+  __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close));
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(3, 1515, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 821, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
   __pyx_v_outinteger = 0;
 
-  __pyx_v_retCode = TA_CDLHARAMI((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
+  __pyx_v_retCode = TA_CDL3OUTSIDE((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLHARAMI, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1518, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDL3OUTSIDE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 824, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1519, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 825, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -45565,7 +55270,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_442stream_CDLHARAMI(CYTHON_UNUSED PyOb
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLHARAMI", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDL3OUTSIDE", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_open);
@@ -45579,99 +55284,129 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_442stream_CDLHARAMI(CYTHON_UNUSED PyOb
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_445stream_CDLHARAMICROSS(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_444stream_CDLHARAMICROSS[] = " CDLHARAMICROSS(open, high, low, close)\n\n    Harami Cross Pattern (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_445stream_CDLHARAMICROSS = {"stream_CDLHARAMICROSS", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_445stream_CDLHARAMICROSS, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_444stream_CDLHARAMICROSS};
-static PyObject *__pyx_pw_5talib_7_ta_lib_445stream_CDLHARAMICROSS(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_413stream_CDL3STARSINSOUTH(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_412stream_CDL3STARSINSOUTH, "stream_CDL3STARSINSOUTH(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDL3STARSINSOUTH(open, high, low, close)\n\nThree Stars In The South (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_413stream_CDL3STARSINSOUTH = {"stream_CDL3STARSINSOUTH", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_413stream_CDL3STARSINSOUTH, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_412stream_CDL3STARSINSOUTH};
+static PyObject *__pyx_pw_5talib_7_ta_lib_413stream_CDL3STARSINSOUTH(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_open = 0;
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_CDLHARAMICROSS (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_CDL3STARSINSOUTH (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 827, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 827, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 827, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 827, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 827, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLHARAMICROSS", 1, 4, 4, 1); __PYX_ERR(3, 1523, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLHARAMICROSS", 1, 4, 4, 2); __PYX_ERR(3, 1523, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLHARAMICROSS", 1, 4, 4, 3); __PYX_ERR(3, 1523, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_CDLHARAMICROSS") < 0)) __PYX_ERR(3, 1523, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDL3STARSINSOUTH", 0) < (0)) __PYX_ERR(5, 827, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDL3STARSINSOUTH", 1, 4, 4, i); __PYX_ERR(5, 827, __pyx_L3_error) }
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
+    } else if (unlikely(__pyx_nargs != 4)) {
       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[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 827, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 827, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 827, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 827, __pyx_L3_error)
     }
     __pyx_v_open = ((PyArrayObject *)values[0]);
     __pyx_v_high = ((PyArrayObject *)values[1]);
     __pyx_v_low = ((PyArrayObject *)values[2]);
     __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_CDLHARAMICROSS", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 1523, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_CDL3STARSINSOUTH", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 827, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLHARAMICROSS", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDL3STARSINSOUTH", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 1523, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 1523, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 1523, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 1523, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_444stream_CDLHARAMICROSS(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 829, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 829, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 829, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 829, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_412stream_CDL3STARSINSOUTH(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_444stream_CDLHARAMICROSS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_412stream_CDL3STARSINSOUTH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
   double *__pyx_v_open_data;
@@ -45685,53 +55420,56 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_444stream_CDLHARAMICROSS(CYTHON_UNUSED
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
-  __Pyx_RefNannySetupContext("stream_CDLHARAMICROSS", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_CDL3STARSINSOUTH", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_open);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1543, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 849, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_open_data = ((double *)__pyx_v_open->data);
+  __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1545, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 851, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_high_data = ((double *)__pyx_v_high->data);
+  __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1547, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 853, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_low_data = ((double *)__pyx_v_low->data);
+  __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1549, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 855, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_close_data = ((double *)__pyx_v_close->data);
+  __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close));
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(3, 1551, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 857, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
   __pyx_v_outinteger = 0;
 
-  __pyx_v_retCode = TA_CDLHARAMICROSS((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
+  __pyx_v_retCode = TA_CDL3STARSINSOUTH((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLHARAMICROSS, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1554, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDL3STARSINSOUTH, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 860, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1555, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 861, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -45741,7 +55479,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_444stream_CDLHARAMICROSS(CYTHON_UNUSED
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLHARAMICROSS", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDL3STARSINSOUTH", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_open);
@@ -45755,99 +55493,129 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_444stream_CDLHARAMICROSS(CYTHON_UNUSED
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_447stream_CDLHIGHWAVE(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_446stream_CDLHIGHWAVE[] = " CDLHIGHWAVE(open, high, low, close)\n\n    High-Wave Candle (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_447stream_CDLHIGHWAVE = {"stream_CDLHIGHWAVE", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_447stream_CDLHIGHWAVE, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_446stream_CDLHIGHWAVE};
-static PyObject *__pyx_pw_5talib_7_ta_lib_447stream_CDLHIGHWAVE(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_415stream_CDL3WHITESOLDIERS(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_414stream_CDL3WHITESOLDIERS, "stream_CDL3WHITESOLDIERS(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDL3WHITESOLDIERS(open, high, low, close)\n\nThree Advancing White Soldiers (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_415stream_CDL3WHITESOLDIERS = {"stream_CDL3WHITESOLDIERS", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_415stream_CDL3WHITESOLDIERS, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_414stream_CDL3WHITESOLDIERS};
+static PyObject *__pyx_pw_5talib_7_ta_lib_415stream_CDL3WHITESOLDIERS(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_open = 0;
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_CDLHIGHWAVE (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_CDL3WHITESOLDIERS (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 863, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 863, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 863, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 863, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 863, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLHIGHWAVE", 1, 4, 4, 1); __PYX_ERR(3, 1559, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLHIGHWAVE", 1, 4, 4, 2); __PYX_ERR(3, 1559, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLHIGHWAVE", 1, 4, 4, 3); __PYX_ERR(3, 1559, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_CDLHIGHWAVE") < 0)) __PYX_ERR(3, 1559, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDL3WHITESOLDIERS", 0) < (0)) __PYX_ERR(5, 863, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDL3WHITESOLDIERS", 1, 4, 4, i); __PYX_ERR(5, 863, __pyx_L3_error) }
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
+    } else if (unlikely(__pyx_nargs != 4)) {
       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[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 863, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 863, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 863, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 863, __pyx_L3_error)
     }
     __pyx_v_open = ((PyArrayObject *)values[0]);
     __pyx_v_high = ((PyArrayObject *)values[1]);
     __pyx_v_low = ((PyArrayObject *)values[2]);
     __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_CDLHIGHWAVE", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 1559, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_CDL3WHITESOLDIERS", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 863, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLHIGHWAVE", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDL3WHITESOLDIERS", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 1559, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 1559, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 1559, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 1559, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_446stream_CDLHIGHWAVE(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 865, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 865, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 865, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 865, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_414stream_CDL3WHITESOLDIERS(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_446stream_CDLHIGHWAVE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_414stream_CDL3WHITESOLDIERS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
   double *__pyx_v_open_data;
@@ -45861,53 +55629,56 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_446stream_CDLHIGHWAVE(CYTHON_UNUSED Py
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
-  __Pyx_RefNannySetupContext("stream_CDLHIGHWAVE", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_CDL3WHITESOLDIERS", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_open);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1579, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 885, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_open_data = ((double *)__pyx_v_open->data);
+  __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1581, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 887, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_high_data = ((double *)__pyx_v_high->data);
+  __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1583, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 889, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_low_data = ((double *)__pyx_v_low->data);
+  __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1585, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 891, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_close_data = ((double *)__pyx_v_close->data);
+  __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close));
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(3, 1587, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 893, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
   __pyx_v_outinteger = 0;
 
-  __pyx_v_retCode = TA_CDLHIGHWAVE((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
+  __pyx_v_retCode = TA_CDL3WHITESOLDIERS((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLHIGHWAVE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1590, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDL3WHITESOLDIERS, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 896, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1591, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 897, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -45917,7 +55688,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_446stream_CDLHIGHWAVE(CYTHON_UNUSED Py
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLHIGHWAVE", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDL3WHITESOLDIERS", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_open);
@@ -45931,99 +55702,146 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_446stream_CDLHIGHWAVE(CYTHON_UNUSED Py
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_449stream_CDLHIKKAKE(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_448stream_CDLHIKKAKE[] = " CDLHIKKAKE(open, high, low, close)\n\n    Hikkake Pattern (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_449stream_CDLHIKKAKE = {"stream_CDLHIKKAKE", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_449stream_CDLHIKKAKE, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_448stream_CDLHIKKAKE};
-static PyObject *__pyx_pw_5talib_7_ta_lib_449stream_CDLHIKKAKE(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_417stream_CDLABANDONEDBABY(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_416stream_CDLABANDONEDBABY, "stream_CDLABANDONEDBABY(ndarray open, ndarray high, ndarray low, ndarray close, double penetration=0.3)\n\nCDLABANDONEDBABY(open, high, low, close[, penetration=?])\n\nAbandoned Baby (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nParameters:\n    penetration: 0.3\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_417stream_CDLABANDONEDBABY = {"stream_CDLABANDONEDBABY", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_417stream_CDLABANDONEDBABY, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_416stream_CDLABANDONEDBABY};
+static PyObject *__pyx_pw_5talib_7_ta_lib_417stream_CDLABANDONEDBABY(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_open = 0;
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
+  double __pyx_v_penetration;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[5] = {0,0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_CDLHIKKAKE (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_CDLABANDONEDBABY (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,&__pyx_mstate_global->__pyx_n_u_penetration,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 899, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  5:
+        values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(5, 899, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 899, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 899, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  0: break;
-        default: goto __pyx_L5_argtuple_error;
-      }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 899, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLHIKKAKE", 1, 4, 4, 1); __PYX_ERR(3, 1595, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLHIKKAKE", 1, 4, 4, 2); __PYX_ERR(3, 1595, __pyx_L3_error)
-        }
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 899, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLHIKKAKE", 1, 4, 4, 3); __PYX_ERR(3, 1595, __pyx_L3_error)
-        }
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
       }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_CDLHIKKAKE") < 0)) __PYX_ERR(3, 1595, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLABANDONEDBABY", 0) < (0)) __PYX_ERR(5, 899, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLABANDONEDBABY", 0, 4, 5, i); __PYX_ERR(5, 899, __pyx_L3_error) }
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
-      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);
+      switch (__pyx_nargs) {
+        case  5:
+        values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(5, 899, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 899, __pyx_L3_error)
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 899, __pyx_L3_error)
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 899, __pyx_L3_error)
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 899, __pyx_L3_error)
+        break;
+        default: goto __pyx_L5_argtuple_error;
+      }
     }
     __pyx_v_open = ((PyArrayObject *)values[0]);
     __pyx_v_high = ((PyArrayObject *)values[1]);
     __pyx_v_low = ((PyArrayObject *)values[2]);
     __pyx_v_close = ((PyArrayObject *)values[3]);
+    if (values[4]) {
+      __pyx_v_penetration = __Pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_penetration == (double)-1) && PyErr_Occurred())) __PYX_ERR(5, 901, __pyx_L3_error)
+    } else {
+      __pyx_v_penetration = ((double)((double)0.3));
+    }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_CDLHIKKAKE", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 1595, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_CDLABANDONEDBABY", 0, 4, 5, __pyx_nargs); __PYX_ERR(5, 899, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLHIKKAKE", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLABANDONEDBABY", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 1595, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 1595, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 1595, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 1595, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_448stream_CDLHIKKAKE(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 901, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 901, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 901, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 901, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_416stream_CDLABANDONEDBABY(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_penetration);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_448stream_CDLHIKKAKE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_416stream_CDLABANDONEDBABY(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
   double *__pyx_v_open_data;
@@ -46037,53 +55855,56 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_448stream_CDLHIKKAKE(CYTHON_UNUSED PyO
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
-  __Pyx_RefNannySetupContext("stream_CDLHIKKAKE", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_CDLABANDONEDBABY", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_open);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1615, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 923, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_open_data = ((double *)__pyx_v_open->data);
+  __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1617, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 925, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_high_data = ((double *)__pyx_v_high->data);
+  __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1619, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 927, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_low_data = ((double *)__pyx_v_low->data);
+  __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1621, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 929, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_close_data = ((double *)__pyx_v_close->data);
+  __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close));
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(3, 1623, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 931, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
   __pyx_v_outinteger = 0;
 
-  __pyx_v_retCode = TA_CDLHIKKAKE((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
+  __pyx_v_retCode = TA_CDLABANDONEDBABY((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, __pyx_v_penetration, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLHIKKAKE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1626, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLABANDONEDBABY, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 934, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1627, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 935, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -46093,7 +55914,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_448stream_CDLHIKKAKE(CYTHON_UNUSED PyO
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLHIKKAKE", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLABANDONEDBABY", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_open);
@@ -46107,99 +55928,129 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_448stream_CDLHIKKAKE(CYTHON_UNUSED PyO
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_451stream_CDLHIKKAKEMOD(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_450stream_CDLHIKKAKEMOD[] = " CDLHIKKAKEMOD(open, high, low, close)\n\n    Modified Hikkake Pattern (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_451stream_CDLHIKKAKEMOD = {"stream_CDLHIKKAKEMOD", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_451stream_CDLHIKKAKEMOD, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_450stream_CDLHIKKAKEMOD};
-static PyObject *__pyx_pw_5talib_7_ta_lib_451stream_CDLHIKKAKEMOD(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_419stream_CDLADVANCEBLOCK(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_418stream_CDLADVANCEBLOCK, "stream_CDLADVANCEBLOCK(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLADVANCEBLOCK(open, high, low, close)\n\nAdvance Block (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_419stream_CDLADVANCEBLOCK = {"stream_CDLADVANCEBLOCK", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_419stream_CDLADVANCEBLOCK, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_418stream_CDLADVANCEBLOCK};
+static PyObject *__pyx_pw_5talib_7_ta_lib_419stream_CDLADVANCEBLOCK(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_open = 0;
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_CDLHIKKAKEMOD (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_CDLADVANCEBLOCK (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 937, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 937, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 937, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 937, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 937, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLHIKKAKEMOD", 1, 4, 4, 1); __PYX_ERR(3, 1631, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLHIKKAKEMOD", 1, 4, 4, 2); __PYX_ERR(3, 1631, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLHIKKAKEMOD", 1, 4, 4, 3); __PYX_ERR(3, 1631, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_CDLHIKKAKEMOD") < 0)) __PYX_ERR(3, 1631, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLADVANCEBLOCK", 0) < (0)) __PYX_ERR(5, 937, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLADVANCEBLOCK", 1, 4, 4, i); __PYX_ERR(5, 937, __pyx_L3_error) }
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
+    } else if (unlikely(__pyx_nargs != 4)) {
       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[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 937, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 937, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 937, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 937, __pyx_L3_error)
     }
     __pyx_v_open = ((PyArrayObject *)values[0]);
     __pyx_v_high = ((PyArrayObject *)values[1]);
     __pyx_v_low = ((PyArrayObject *)values[2]);
     __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_CDLHIKKAKEMOD", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 1631, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_CDLADVANCEBLOCK", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 937, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLHIKKAKEMOD", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLADVANCEBLOCK", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 1631, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 1631, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 1631, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 1631, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_450stream_CDLHIKKAKEMOD(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 939, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 939, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 939, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 939, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_418stream_CDLADVANCEBLOCK(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_450stream_CDLHIKKAKEMOD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_418stream_CDLADVANCEBLOCK(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
   double *__pyx_v_open_data;
@@ -46213,53 +56064,56 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_450stream_CDLHIKKAKEMOD(CYTHON_UNUSED
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
-  __Pyx_RefNannySetupContext("stream_CDLHIKKAKEMOD", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_CDLADVANCEBLOCK", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_open);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1651, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 959, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_open_data = ((double *)__pyx_v_open->data);
+  __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1653, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 961, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_high_data = ((double *)__pyx_v_high->data);
+  __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1655, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 963, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_low_data = ((double *)__pyx_v_low->data);
+  __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1657, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 965, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_close_data = ((double *)__pyx_v_close->data);
+  __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close));
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(3, 1659, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 967, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
   __pyx_v_outinteger = 0;
 
-  __pyx_v_retCode = TA_CDLHIKKAKEMOD((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
+  __pyx_v_retCode = TA_CDLADVANCEBLOCK((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLHIKKAKEMOD, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1662, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLADVANCEBLOCK, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 970, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1663, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 971, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -46269,7 +56123,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_450stream_CDLHIKKAKEMOD(CYTHON_UNUSED
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLHIKKAKEMOD", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLADVANCEBLOCK", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_open);
@@ -46283,99 +56137,129 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_450stream_CDLHIKKAKEMOD(CYTHON_UNUSED
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_453stream_CDLHOMINGPIGEON(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_452stream_CDLHOMINGPIGEON[] = " CDLHOMINGPIGEON(open, high, low, close)\n\n    Homing Pigeon (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_453stream_CDLHOMINGPIGEON = {"stream_CDLHOMINGPIGEON", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_453stream_CDLHOMINGPIGEON, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_452stream_CDLHOMINGPIGEON};
-static PyObject *__pyx_pw_5talib_7_ta_lib_453stream_CDLHOMINGPIGEON(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_421stream_CDLBELTHOLD(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_420stream_CDLBELTHOLD, "stream_CDLBELTHOLD(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLBELTHOLD(open, high, low, close)\n\nBelt-hold (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_421stream_CDLBELTHOLD = {"stream_CDLBELTHOLD", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_421stream_CDLBELTHOLD, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_420stream_CDLBELTHOLD};
+static PyObject *__pyx_pw_5talib_7_ta_lib_421stream_CDLBELTHOLD(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_open = 0;
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_CDLHOMINGPIGEON (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_CDLBELTHOLD (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 973, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 973, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 973, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 973, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 973, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLHOMINGPIGEON", 1, 4, 4, 1); __PYX_ERR(3, 1667, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLHOMINGPIGEON", 1, 4, 4, 2); __PYX_ERR(3, 1667, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLHOMINGPIGEON", 1, 4, 4, 3); __PYX_ERR(3, 1667, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_CDLHOMINGPIGEON") < 0)) __PYX_ERR(3, 1667, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLBELTHOLD", 0) < (0)) __PYX_ERR(5, 973, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLBELTHOLD", 1, 4, 4, i); __PYX_ERR(5, 973, __pyx_L3_error) }
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
+    } else if (unlikely(__pyx_nargs != 4)) {
       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[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 973, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 973, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 973, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 973, __pyx_L3_error)
     }
     __pyx_v_open = ((PyArrayObject *)values[0]);
     __pyx_v_high = ((PyArrayObject *)values[1]);
     __pyx_v_low = ((PyArrayObject *)values[2]);
     __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_CDLHOMINGPIGEON", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 1667, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_CDLBELTHOLD", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 973, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLHOMINGPIGEON", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLBELTHOLD", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 1667, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 1667, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 1667, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 1667, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_452stream_CDLHOMINGPIGEON(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 975, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 975, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 975, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 975, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_420stream_CDLBELTHOLD(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_452stream_CDLHOMINGPIGEON(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_420stream_CDLBELTHOLD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
   double *__pyx_v_open_data;
@@ -46389,53 +56273,56 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_452stream_CDLHOMINGPIGEON(CYTHON_UNUSE
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
-  __Pyx_RefNannySetupContext("stream_CDLHOMINGPIGEON", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_CDLBELTHOLD", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_open);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1687, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 995, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_open_data = ((double *)__pyx_v_open->data);
+  __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1689, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 997, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_high_data = ((double *)__pyx_v_high->data);
+  __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1691, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 999, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_low_data = ((double *)__pyx_v_low->data);
+  __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1693, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1001, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_close_data = ((double *)__pyx_v_close->data);
+  __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close));
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(3, 1695, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 1003, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
   __pyx_v_outinteger = 0;
 
-  __pyx_v_retCode = TA_CDLHOMINGPIGEON((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
+  __pyx_v_retCode = TA_CDLBELTHOLD((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLHOMINGPIGEON, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1698, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLBELTHOLD, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1006, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1699, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1007, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -46445,7 +56332,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_452stream_CDLHOMINGPIGEON(CYTHON_UNUSE
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLHOMINGPIGEON", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLBELTHOLD", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_open);
@@ -46459,99 +56346,129 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_452stream_CDLHOMINGPIGEON(CYTHON_UNUSE
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_455stream_CDLIDENTICAL3CROWS(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_454stream_CDLIDENTICAL3CROWS[] = " CDLIDENTICAL3CROWS(open, high, low, close)\n\n    Identical Three Crows (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_455stream_CDLIDENTICAL3CROWS = {"stream_CDLIDENTICAL3CROWS", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_455stream_CDLIDENTICAL3CROWS, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_454stream_CDLIDENTICAL3CROWS};
-static PyObject *__pyx_pw_5talib_7_ta_lib_455stream_CDLIDENTICAL3CROWS(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_423stream_CDLBREAKAWAY(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_422stream_CDLBREAKAWAY, "stream_CDLBREAKAWAY(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLBREAKAWAY(open, high, low, close)\n\nBreakaway (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_423stream_CDLBREAKAWAY = {"stream_CDLBREAKAWAY", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_423stream_CDLBREAKAWAY, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_422stream_CDLBREAKAWAY};
+static PyObject *__pyx_pw_5talib_7_ta_lib_423stream_CDLBREAKAWAY(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_open = 0;
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_CDLIDENTICAL3CROWS (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_CDLBREAKAWAY (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 1009, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1009, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1009, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1009, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1009, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLIDENTICAL3CROWS", 1, 4, 4, 1); __PYX_ERR(3, 1703, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLIDENTICAL3CROWS", 1, 4, 4, 2); __PYX_ERR(3, 1703, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLIDENTICAL3CROWS", 1, 4, 4, 3); __PYX_ERR(3, 1703, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_CDLIDENTICAL3CROWS") < 0)) __PYX_ERR(3, 1703, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLBREAKAWAY", 0) < (0)) __PYX_ERR(5, 1009, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLBREAKAWAY", 1, 4, 4, i); __PYX_ERR(5, 1009, __pyx_L3_error) }
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
+    } else if (unlikely(__pyx_nargs != 4)) {
       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[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1009, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1009, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1009, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1009, __pyx_L3_error)
     }
     __pyx_v_open = ((PyArrayObject *)values[0]);
     __pyx_v_high = ((PyArrayObject *)values[1]);
     __pyx_v_low = ((PyArrayObject *)values[2]);
     __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_CDLIDENTICAL3CROWS", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 1703, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_CDLBREAKAWAY", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 1009, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLIDENTICAL3CROWS", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLBREAKAWAY", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 1703, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 1703, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 1703, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 1703, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_454stream_CDLIDENTICAL3CROWS(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 1011, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 1011, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 1011, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 1011, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_422stream_CDLBREAKAWAY(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_454stream_CDLIDENTICAL3CROWS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_422stream_CDLBREAKAWAY(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
   double *__pyx_v_open_data;
@@ -46565,53 +56482,56 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_454stream_CDLIDENTICAL3CROWS(CYTHON_UN
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
-  __Pyx_RefNannySetupContext("stream_CDLIDENTICAL3CROWS", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_CDLBREAKAWAY", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_open);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1723, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1031, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_open_data = ((double *)__pyx_v_open->data);
+  __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1725, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1033, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_high_data = ((double *)__pyx_v_high->data);
+  __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1727, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1035, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_low_data = ((double *)__pyx_v_low->data);
+  __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1729, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1037, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_close_data = ((double *)__pyx_v_close->data);
+  __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close));
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(3, 1731, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 1039, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
   __pyx_v_outinteger = 0;
 
-  __pyx_v_retCode = TA_CDLIDENTICAL3CROWS((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
+  __pyx_v_retCode = TA_CDLBREAKAWAY((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLIDENTICAL3CROWS, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1734, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLBREAKAWAY, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1042, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1735, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1043, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -46621,7 +56541,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_454stream_CDLIDENTICAL3CROWS(CYTHON_UN
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLIDENTICAL3CROWS", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLBREAKAWAY", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_open);
@@ -46635,99 +56555,129 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_454stream_CDLIDENTICAL3CROWS(CYTHON_UN
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_457stream_CDLINNECK(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_456stream_CDLINNECK[] = " CDLINNECK(open, high, low, close)\n\n    In-Neck Pattern (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_457stream_CDLINNECK = {"stream_CDLINNECK", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_457stream_CDLINNECK, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_456stream_CDLINNECK};
-static PyObject *__pyx_pw_5talib_7_ta_lib_457stream_CDLINNECK(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_425stream_CDLCLOSINGMARUBOZU(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_424stream_CDLCLOSINGMARUBOZU, "stream_CDLCLOSINGMARUBOZU(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLCLOSINGMARUBOZU(open, high, low, close)\n\nClosing Marubozu (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_425stream_CDLCLOSINGMARUBOZU = {"stream_CDLCLOSINGMARUBOZU", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_425stream_CDLCLOSINGMARUBOZU, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_424stream_CDLCLOSINGMARUBOZU};
+static PyObject *__pyx_pw_5talib_7_ta_lib_425stream_CDLCLOSINGMARUBOZU(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_open = 0;
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_CDLINNECK (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_CDLCLOSINGMARUBOZU (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 1045, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1045, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1045, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1045, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1045, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLINNECK", 1, 4, 4, 1); __PYX_ERR(3, 1739, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLINNECK", 1, 4, 4, 2); __PYX_ERR(3, 1739, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLINNECK", 1, 4, 4, 3); __PYX_ERR(3, 1739, __pyx_L3_error)
-        }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLCLOSINGMARUBOZU", 0) < (0)) __PYX_ERR(5, 1045, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLCLOSINGMARUBOZU", 1, 4, 4, i); __PYX_ERR(5, 1045, __pyx_L3_error) }
       }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_CDLINNECK") < 0)) __PYX_ERR(3, 1739, __pyx_L3_error)
-      }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
+    } else if (unlikely(__pyx_nargs != 4)) {
       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[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1045, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1045, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1045, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1045, __pyx_L3_error)
     }
     __pyx_v_open = ((PyArrayObject *)values[0]);
     __pyx_v_high = ((PyArrayObject *)values[1]);
     __pyx_v_low = ((PyArrayObject *)values[2]);
     __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_CDLINNECK", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 1739, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_CDLCLOSINGMARUBOZU", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 1045, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLINNECK", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLCLOSINGMARUBOZU", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 1739, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 1739, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 1739, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 1739, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_456stream_CDLINNECK(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 1047, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 1047, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 1047, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 1047, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_424stream_CDLCLOSINGMARUBOZU(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_456stream_CDLINNECK(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_424stream_CDLCLOSINGMARUBOZU(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
   double *__pyx_v_open_data;
@@ -46741,53 +56691,56 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_456stream_CDLINNECK(CYTHON_UNUSED PyOb
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
-  __Pyx_RefNannySetupContext("stream_CDLINNECK", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_CDLCLOSINGMARUBOZU", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_open);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1759, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1067, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_open_data = ((double *)__pyx_v_open->data);
+  __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1761, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1069, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_high_data = ((double *)__pyx_v_high->data);
+  __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1763, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1071, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_low_data = ((double *)__pyx_v_low->data);
+  __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1765, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1073, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_close_data = ((double *)__pyx_v_close->data);
+  __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close));
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(3, 1767, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 1075, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
   __pyx_v_outinteger = 0;
 
-  __pyx_v_retCode = TA_CDLINNECK((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
+  __pyx_v_retCode = TA_CDLCLOSINGMARUBOZU((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLINNECK, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1770, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLCLOSINGMARUBOZU, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1078, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1771, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1079, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -46797,7 +56750,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_456stream_CDLINNECK(CYTHON_UNUSED PyOb
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLINNECK", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLCLOSINGMARUBOZU", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_open);
@@ -46811,99 +56764,129 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_456stream_CDLINNECK(CYTHON_UNUSED PyOb
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_459stream_CDLINVERTEDHAMMER(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_458stream_CDLINVERTEDHAMMER[] = " CDLINVERTEDHAMMER(open, high, low, close)\n\n    Inverted Hammer (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_459stream_CDLINVERTEDHAMMER = {"stream_CDLINVERTEDHAMMER", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_459stream_CDLINVERTEDHAMMER, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_458stream_CDLINVERTEDHAMMER};
-static PyObject *__pyx_pw_5talib_7_ta_lib_459stream_CDLINVERTEDHAMMER(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_427stream_CDLCONCEALBABYSWALL(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_426stream_CDLCONCEALBABYSWALL, "stream_CDLCONCEALBABYSWALL(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLCONCEALBABYSWALL(open, high, low, close)\n\nConcealing Baby Swallow (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_427stream_CDLCONCEALBABYSWALL = {"stream_CDLCONCEALBABYSWALL", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_427stream_CDLCONCEALBABYSWALL, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_426stream_CDLCONCEALBABYSWALL};
+static PyObject *__pyx_pw_5talib_7_ta_lib_427stream_CDLCONCEALBABYSWALL(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_open = 0;
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_CDLINVERTEDHAMMER (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_CDLCONCEALBABYSWALL (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 1081, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1081, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1081, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1081, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1081, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLINVERTEDHAMMER", 1, 4, 4, 1); __PYX_ERR(3, 1775, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLINVERTEDHAMMER", 1, 4, 4, 2); __PYX_ERR(3, 1775, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLINVERTEDHAMMER", 1, 4, 4, 3); __PYX_ERR(3, 1775, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_CDLINVERTEDHAMMER") < 0)) __PYX_ERR(3, 1775, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLCONCEALBABYSWALL", 0) < (0)) __PYX_ERR(5, 1081, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLCONCEALBABYSWALL", 1, 4, 4, i); __PYX_ERR(5, 1081, __pyx_L3_error) }
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
+    } else if (unlikely(__pyx_nargs != 4)) {
       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[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1081, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1081, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1081, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1081, __pyx_L3_error)
     }
     __pyx_v_open = ((PyArrayObject *)values[0]);
     __pyx_v_high = ((PyArrayObject *)values[1]);
     __pyx_v_low = ((PyArrayObject *)values[2]);
     __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_CDLINVERTEDHAMMER", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 1775, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_CDLCONCEALBABYSWALL", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 1081, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLINVERTEDHAMMER", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLCONCEALBABYSWALL", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 1775, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 1775, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 1775, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 1775, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_458stream_CDLINVERTEDHAMMER(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 1083, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 1083, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 1083, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 1083, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_426stream_CDLCONCEALBABYSWALL(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_458stream_CDLINVERTEDHAMMER(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_426stream_CDLCONCEALBABYSWALL(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
   double *__pyx_v_open_data;
@@ -46917,53 +56900,56 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_458stream_CDLINVERTEDHAMMER(CYTHON_UNU
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
-  __Pyx_RefNannySetupContext("stream_CDLINVERTEDHAMMER", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_CDLCONCEALBABYSWALL", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_open);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1795, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1103, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_open_data = ((double *)__pyx_v_open->data);
+  __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1797, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1105, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_high_data = ((double *)__pyx_v_high->data);
+  __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1799, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1107, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_low_data = ((double *)__pyx_v_low->data);
+  __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1801, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1109, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_close_data = ((double *)__pyx_v_close->data);
+  __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close));
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(3, 1803, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 1111, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
   __pyx_v_outinteger = 0;
 
-  __pyx_v_retCode = TA_CDLINVERTEDHAMMER((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
+  __pyx_v_retCode = TA_CDLCONCEALBABYSWALL((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLINVERTEDHAMMER, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1806, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLCONCEALBABYSWALL, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1114, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1807, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1115, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -46973,7 +56959,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_458stream_CDLINVERTEDHAMMER(CYTHON_UNU
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLINVERTEDHAMMER", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLCONCEALBABYSWALL", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_open);
@@ -46987,99 +56973,129 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_458stream_CDLINVERTEDHAMMER(CYTHON_UNU
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_461stream_CDLKICKING(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_460stream_CDLKICKING[] = " CDLKICKING(open, high, low, close)\n\n    Kicking (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_461stream_CDLKICKING = {"stream_CDLKICKING", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_461stream_CDLKICKING, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_460stream_CDLKICKING};
-static PyObject *__pyx_pw_5talib_7_ta_lib_461stream_CDLKICKING(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_429stream_CDLCOUNTERATTACK(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_428stream_CDLCOUNTERATTACK, "stream_CDLCOUNTERATTACK(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLCOUNTERATTACK(open, high, low, close)\n\nCounterattack (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_429stream_CDLCOUNTERATTACK = {"stream_CDLCOUNTERATTACK", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_429stream_CDLCOUNTERATTACK, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_428stream_CDLCOUNTERATTACK};
+static PyObject *__pyx_pw_5talib_7_ta_lib_429stream_CDLCOUNTERATTACK(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_open = 0;
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_CDLKICKING (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_CDLCOUNTERATTACK (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 1117, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1117, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1117, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1117, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1117, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLKICKING", 1, 4, 4, 1); __PYX_ERR(3, 1811, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLKICKING", 1, 4, 4, 2); __PYX_ERR(3, 1811, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLKICKING", 1, 4, 4, 3); __PYX_ERR(3, 1811, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_CDLKICKING") < 0)) __PYX_ERR(3, 1811, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLCOUNTERATTACK", 0) < (0)) __PYX_ERR(5, 1117, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLCOUNTERATTACK", 1, 4, 4, i); __PYX_ERR(5, 1117, __pyx_L3_error) }
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
+    } else if (unlikely(__pyx_nargs != 4)) {
       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[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1117, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1117, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1117, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1117, __pyx_L3_error)
     }
     __pyx_v_open = ((PyArrayObject *)values[0]);
     __pyx_v_high = ((PyArrayObject *)values[1]);
     __pyx_v_low = ((PyArrayObject *)values[2]);
     __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_CDLKICKING", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 1811, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_CDLCOUNTERATTACK", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 1117, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLKICKING", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLCOUNTERATTACK", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 1811, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 1811, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 1811, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 1811, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_460stream_CDLKICKING(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 1119, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 1119, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 1119, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 1119, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_428stream_CDLCOUNTERATTACK(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_460stream_CDLKICKING(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_428stream_CDLCOUNTERATTACK(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
   double *__pyx_v_open_data;
@@ -47093,53 +57109,56 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_460stream_CDLKICKING(CYTHON_UNUSED PyO
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
-  __Pyx_RefNannySetupContext("stream_CDLKICKING", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_CDLCOUNTERATTACK", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_open);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1831, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1139, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_open_data = ((double *)__pyx_v_open->data);
+  __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1833, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1141, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_high_data = ((double *)__pyx_v_high->data);
+  __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1835, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1143, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_low_data = ((double *)__pyx_v_low->data);
+  __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1837, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1145, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_close_data = ((double *)__pyx_v_close->data);
+  __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close));
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(3, 1839, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 1147, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
   __pyx_v_outinteger = 0;
 
-  __pyx_v_retCode = TA_CDLKICKING((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
+  __pyx_v_retCode = TA_CDLCOUNTERATTACK((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLKICKING, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1842, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLCOUNTERATTACK, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1150, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1843, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1151, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -47149,7 +57168,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_460stream_CDLKICKING(CYTHON_UNUSED PyO
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLKICKING", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLCOUNTERATTACK", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_open);
@@ -47163,99 +57182,146 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_460stream_CDLKICKING(CYTHON_UNUSED PyO
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_463stream_CDLKICKINGBYLENGTH(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_462stream_CDLKICKINGBYLENGTH[] = " CDLKICKINGBYLENGTH(open, high, low, close)\n\n    Kicking - bull/bear determined by the longer marubozu (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_463stream_CDLKICKINGBYLENGTH = {"stream_CDLKICKINGBYLENGTH", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_463stream_CDLKICKINGBYLENGTH, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_462stream_CDLKICKINGBYLENGTH};
-static PyObject *__pyx_pw_5talib_7_ta_lib_463stream_CDLKICKINGBYLENGTH(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_431stream_CDLDARKCLOUDCOVER(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_430stream_CDLDARKCLOUDCOVER, "stream_CDLDARKCLOUDCOVER(ndarray open, ndarray high, ndarray low, ndarray close, double penetration=0.5)\n\nCDLDARKCLOUDCOVER(open, high, low, close[, penetration=?])\n\nDark Cloud Cover (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nParameters:\n    penetration: 0.5\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_431stream_CDLDARKCLOUDCOVER = {"stream_CDLDARKCLOUDCOVER", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_431stream_CDLDARKCLOUDCOVER, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_430stream_CDLDARKCLOUDCOVER};
+static PyObject *__pyx_pw_5talib_7_ta_lib_431stream_CDLDARKCLOUDCOVER(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_open = 0;
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
+  double __pyx_v_penetration;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[5] = {0,0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_CDLKICKINGBYLENGTH (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_CDLDARKCLOUDCOVER (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,&__pyx_mstate_global->__pyx_n_u_penetration,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 1153, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  5:
+        values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(5, 1153, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1153, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1153, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  0: break;
-        default: goto __pyx_L5_argtuple_error;
-      }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1153, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLKICKINGBYLENGTH", 1, 4, 4, 1); __PYX_ERR(3, 1847, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLKICKINGBYLENGTH", 1, 4, 4, 2); __PYX_ERR(3, 1847, __pyx_L3_error)
-        }
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1153, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLKICKINGBYLENGTH", 1, 4, 4, 3); __PYX_ERR(3, 1847, __pyx_L3_error)
-        }
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
       }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_CDLKICKINGBYLENGTH") < 0)) __PYX_ERR(3, 1847, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLDARKCLOUDCOVER", 0) < (0)) __PYX_ERR(5, 1153, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLDARKCLOUDCOVER", 0, 4, 5, i); __PYX_ERR(5, 1153, __pyx_L3_error) }
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
-      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);
+      switch (__pyx_nargs) {
+        case  5:
+        values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(5, 1153, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1153, __pyx_L3_error)
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1153, __pyx_L3_error)
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1153, __pyx_L3_error)
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1153, __pyx_L3_error)
+        break;
+        default: goto __pyx_L5_argtuple_error;
+      }
     }
     __pyx_v_open = ((PyArrayObject *)values[0]);
     __pyx_v_high = ((PyArrayObject *)values[1]);
     __pyx_v_low = ((PyArrayObject *)values[2]);
     __pyx_v_close = ((PyArrayObject *)values[3]);
+    if (values[4]) {
+      __pyx_v_penetration = __Pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_penetration == (double)-1) && PyErr_Occurred())) __PYX_ERR(5, 1155, __pyx_L3_error)
+    } else {
+      __pyx_v_penetration = ((double)((double)0.5));
+    }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_CDLKICKINGBYLENGTH", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 1847, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_CDLDARKCLOUDCOVER", 0, 4, 5, __pyx_nargs); __PYX_ERR(5, 1153, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLKICKINGBYLENGTH", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLDARKCLOUDCOVER", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 1847, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 1847, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 1847, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 1847, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_462stream_CDLKICKINGBYLENGTH(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 1155, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 1155, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 1155, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 1155, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_430stream_CDLDARKCLOUDCOVER(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_penetration);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_462stream_CDLKICKINGBYLENGTH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_430stream_CDLDARKCLOUDCOVER(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
   double *__pyx_v_open_data;
@@ -47269,53 +57335,56 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_462stream_CDLKICKINGBYLENGTH(CYTHON_UN
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
-  __Pyx_RefNannySetupContext("stream_CDLKICKINGBYLENGTH", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_CDLDARKCLOUDCOVER", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_open);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1867, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1177, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_open_data = ((double *)__pyx_v_open->data);
+  __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1869, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1179, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_high_data = ((double *)__pyx_v_high->data);
+  __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1871, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1181, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_low_data = ((double *)__pyx_v_low->data);
+  __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1873, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1183, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_close_data = ((double *)__pyx_v_close->data);
+  __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close));
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(3, 1875, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 1185, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
   __pyx_v_outinteger = 0;
 
-  __pyx_v_retCode = TA_CDLKICKINGBYLENGTH((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
+  __pyx_v_retCode = TA_CDLDARKCLOUDCOVER((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, __pyx_v_penetration, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLKICKINGBYLENGTH, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1878, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLDARKCLOUDCOVER, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1188, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1879, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1189, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -47325,7 +57394,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_462stream_CDLKICKINGBYLENGTH(CYTHON_UN
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLKICKINGBYLENGTH", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLDARKCLOUDCOVER", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_open);
@@ -47339,99 +57408,129 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_462stream_CDLKICKINGBYLENGTH(CYTHON_UN
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_465stream_CDLLADDERBOTTOM(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_464stream_CDLLADDERBOTTOM[] = " CDLLADDERBOTTOM(open, high, low, close)\n\n    Ladder Bottom (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_465stream_CDLLADDERBOTTOM = {"stream_CDLLADDERBOTTOM", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_465stream_CDLLADDERBOTTOM, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_464stream_CDLLADDERBOTTOM};
-static PyObject *__pyx_pw_5talib_7_ta_lib_465stream_CDLLADDERBOTTOM(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_433stream_CDLDOJI(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_432stream_CDLDOJI, "stream_CDLDOJI(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLDOJI(open, high, low, close)\n\nDoji (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_433stream_CDLDOJI = {"stream_CDLDOJI", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_433stream_CDLDOJI, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_432stream_CDLDOJI};
+static PyObject *__pyx_pw_5talib_7_ta_lib_433stream_CDLDOJI(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_open = 0;
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_CDLLADDERBOTTOM (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_CDLDOJI (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 1191, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1191, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1191, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1191, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1191, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLLADDERBOTTOM", 1, 4, 4, 1); __PYX_ERR(3, 1883, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLLADDERBOTTOM", 1, 4, 4, 2); __PYX_ERR(3, 1883, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLLADDERBOTTOM", 1, 4, 4, 3); __PYX_ERR(3, 1883, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_CDLLADDERBOTTOM") < 0)) __PYX_ERR(3, 1883, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLDOJI", 0) < (0)) __PYX_ERR(5, 1191, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLDOJI", 1, 4, 4, i); __PYX_ERR(5, 1191, __pyx_L3_error) }
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
+    } else if (unlikely(__pyx_nargs != 4)) {
       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[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1191, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1191, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1191, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1191, __pyx_L3_error)
     }
     __pyx_v_open = ((PyArrayObject *)values[0]);
     __pyx_v_high = ((PyArrayObject *)values[1]);
     __pyx_v_low = ((PyArrayObject *)values[2]);
     __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_CDLLADDERBOTTOM", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 1883, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_CDLDOJI", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 1191, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLLADDERBOTTOM", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLDOJI", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 1883, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 1883, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 1883, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 1883, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_464stream_CDLLADDERBOTTOM(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 1193, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 1193, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 1193, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 1193, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_432stream_CDLDOJI(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_464stream_CDLLADDERBOTTOM(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_432stream_CDLDOJI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
   double *__pyx_v_open_data;
@@ -47445,53 +57544,56 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_464stream_CDLLADDERBOTTOM(CYTHON_UNUSE
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
-  __Pyx_RefNannySetupContext("stream_CDLLADDERBOTTOM", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_CDLDOJI", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_open);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1903, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1213, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_open_data = ((double *)__pyx_v_open->data);
+  __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1905, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1215, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_high_data = ((double *)__pyx_v_high->data);
+  __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1907, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1217, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_low_data = ((double *)__pyx_v_low->data);
+  __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1909, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1219, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_close_data = ((double *)__pyx_v_close->data);
+  __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close));
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(3, 1911, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 1221, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
   __pyx_v_outinteger = 0;
 
-  __pyx_v_retCode = TA_CDLLADDERBOTTOM((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
+  __pyx_v_retCode = TA_CDLDOJI((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLLADDERBOTTOM, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1914, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLDOJI, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1224, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1915, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1225, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -47501,7 +57603,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_464stream_CDLLADDERBOTTOM(CYTHON_UNUSE
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLLADDERBOTTOM", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLDOJI", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_open);
@@ -47515,99 +57617,129 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_464stream_CDLLADDERBOTTOM(CYTHON_UNUSE
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_467stream_CDLLONGLEGGEDDOJI(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_466stream_CDLLONGLEGGEDDOJI[] = " CDLLONGLEGGEDDOJI(open, high, low, close)\n\n    Long Legged Doji (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_467stream_CDLLONGLEGGEDDOJI = {"stream_CDLLONGLEGGEDDOJI", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_467stream_CDLLONGLEGGEDDOJI, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_466stream_CDLLONGLEGGEDDOJI};
-static PyObject *__pyx_pw_5talib_7_ta_lib_467stream_CDLLONGLEGGEDDOJI(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_435stream_CDLDOJISTAR(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_434stream_CDLDOJISTAR, "stream_CDLDOJISTAR(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLDOJISTAR(open, high, low, close)\n\nDoji Star (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_435stream_CDLDOJISTAR = {"stream_CDLDOJISTAR", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_435stream_CDLDOJISTAR, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_434stream_CDLDOJISTAR};
+static PyObject *__pyx_pw_5talib_7_ta_lib_435stream_CDLDOJISTAR(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_open = 0;
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_CDLLONGLEGGEDDOJI (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_CDLDOJISTAR (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 1227, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1227, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1227, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1227, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1227, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLLONGLEGGEDDOJI", 1, 4, 4, 1); __PYX_ERR(3, 1919, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLLONGLEGGEDDOJI", 1, 4, 4, 2); __PYX_ERR(3, 1919, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLLONGLEGGEDDOJI", 1, 4, 4, 3); __PYX_ERR(3, 1919, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_CDLLONGLEGGEDDOJI") < 0)) __PYX_ERR(3, 1919, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLDOJISTAR", 0) < (0)) __PYX_ERR(5, 1227, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLDOJISTAR", 1, 4, 4, i); __PYX_ERR(5, 1227, __pyx_L3_error) }
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
+    } else if (unlikely(__pyx_nargs != 4)) {
       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[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1227, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1227, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1227, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1227, __pyx_L3_error)
     }
     __pyx_v_open = ((PyArrayObject *)values[0]);
     __pyx_v_high = ((PyArrayObject *)values[1]);
     __pyx_v_low = ((PyArrayObject *)values[2]);
     __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_CDLLONGLEGGEDDOJI", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 1919, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_CDLDOJISTAR", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 1227, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLLONGLEGGEDDOJI", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLDOJISTAR", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 1919, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 1919, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 1919, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 1919, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_466stream_CDLLONGLEGGEDDOJI(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 1229, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 1229, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 1229, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 1229, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_434stream_CDLDOJISTAR(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_466stream_CDLLONGLEGGEDDOJI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_434stream_CDLDOJISTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
   double *__pyx_v_open_data;
@@ -47621,53 +57753,56 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_466stream_CDLLONGLEGGEDDOJI(CYTHON_UNU
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
-  __Pyx_RefNannySetupContext("stream_CDLLONGLEGGEDDOJI", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_CDLDOJISTAR", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_open);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1939, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1249, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_open_data = ((double *)__pyx_v_open->data);
+  __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1941, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1251, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_high_data = ((double *)__pyx_v_high->data);
+  __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1943, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1253, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_low_data = ((double *)__pyx_v_low->data);
+  __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1945, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1255, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_close_data = ((double *)__pyx_v_close->data);
+  __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close));
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(3, 1947, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 1257, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
   __pyx_v_outinteger = 0;
 
-  __pyx_v_retCode = TA_CDLLONGLEGGEDDOJI((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
+  __pyx_v_retCode = TA_CDLDOJISTAR((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLLONGLEGGEDDOJI, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1950, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLDOJISTAR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1260, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1951, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1261, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -47677,7 +57812,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_466stream_CDLLONGLEGGEDDOJI(CYTHON_UNU
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLLONGLEGGEDDOJI", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLDOJISTAR", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_open);
@@ -47691,99 +57826,129 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_466stream_CDLLONGLEGGEDDOJI(CYTHON_UNU
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_469stream_CDLLONGLINE(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_468stream_CDLLONGLINE[] = " CDLLONGLINE(open, high, low, close)\n\n    Long Line Candle (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_469stream_CDLLONGLINE = {"stream_CDLLONGLINE", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_469stream_CDLLONGLINE, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_468stream_CDLLONGLINE};
-static PyObject *__pyx_pw_5talib_7_ta_lib_469stream_CDLLONGLINE(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_437stream_CDLDRAGONFLYDOJI(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_436stream_CDLDRAGONFLYDOJI, "stream_CDLDRAGONFLYDOJI(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLDRAGONFLYDOJI(open, high, low, close)\n\nDragonfly Doji (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_437stream_CDLDRAGONFLYDOJI = {"stream_CDLDRAGONFLYDOJI", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_437stream_CDLDRAGONFLYDOJI, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_436stream_CDLDRAGONFLYDOJI};
+static PyObject *__pyx_pw_5talib_7_ta_lib_437stream_CDLDRAGONFLYDOJI(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_open = 0;
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_CDLLONGLINE (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_CDLDRAGONFLYDOJI (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 1263, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1263, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1263, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1263, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1263, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLLONGLINE", 1, 4, 4, 1); __PYX_ERR(3, 1955, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLLONGLINE", 1, 4, 4, 2); __PYX_ERR(3, 1955, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLLONGLINE", 1, 4, 4, 3); __PYX_ERR(3, 1955, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_CDLLONGLINE") < 0)) __PYX_ERR(3, 1955, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLDRAGONFLYDOJI", 0) < (0)) __PYX_ERR(5, 1263, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLDRAGONFLYDOJI", 1, 4, 4, i); __PYX_ERR(5, 1263, __pyx_L3_error) }
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
+    } else if (unlikely(__pyx_nargs != 4)) {
       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[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1263, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1263, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1263, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1263, __pyx_L3_error)
     }
     __pyx_v_open = ((PyArrayObject *)values[0]);
     __pyx_v_high = ((PyArrayObject *)values[1]);
     __pyx_v_low = ((PyArrayObject *)values[2]);
     __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_CDLLONGLINE", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 1955, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_CDLDRAGONFLYDOJI", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 1263, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLLONGLINE", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLDRAGONFLYDOJI", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 1955, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 1955, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 1955, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 1955, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_468stream_CDLLONGLINE(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 1265, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 1265, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 1265, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 1265, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_436stream_CDLDRAGONFLYDOJI(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_468stream_CDLLONGLINE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_436stream_CDLDRAGONFLYDOJI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
   double *__pyx_v_open_data;
@@ -47797,53 +57962,56 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_468stream_CDLLONGLINE(CYTHON_UNUSED Py
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
-  __Pyx_RefNannySetupContext("stream_CDLLONGLINE", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_CDLDRAGONFLYDOJI", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_open);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1975, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1285, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_open_data = ((double *)__pyx_v_open->data);
+  __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1977, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1287, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_high_data = ((double *)__pyx_v_high->data);
+  __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1979, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1289, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_low_data = ((double *)__pyx_v_low->data);
+  __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1981, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1291, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_close_data = ((double *)__pyx_v_close->data);
+  __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close));
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(3, 1983, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 1293, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
   __pyx_v_outinteger = 0;
 
-  __pyx_v_retCode = TA_CDLLONGLINE((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
+  __pyx_v_retCode = TA_CDLDRAGONFLYDOJI((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLLONGLINE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1986, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLDRAGONFLYDOJI, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1296, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1987, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1297, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -47853,7 +58021,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_468stream_CDLLONGLINE(CYTHON_UNUSED Py
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLLONGLINE", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLDRAGONFLYDOJI", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_open);
@@ -47867,99 +58035,129 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_468stream_CDLLONGLINE(CYTHON_UNUSED Py
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_471stream_CDLMARUBOZU(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_470stream_CDLMARUBOZU[] = " CDLMARUBOZU(open, high, low, close)\n\n    Marubozu (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_471stream_CDLMARUBOZU = {"stream_CDLMARUBOZU", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_471stream_CDLMARUBOZU, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_470stream_CDLMARUBOZU};
-static PyObject *__pyx_pw_5talib_7_ta_lib_471stream_CDLMARUBOZU(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_439stream_CDLENGULFING(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_438stream_CDLENGULFING, "stream_CDLENGULFING(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLENGULFING(open, high, low, close)\n\nEngulfing Pattern (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_439stream_CDLENGULFING = {"stream_CDLENGULFING", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_439stream_CDLENGULFING, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_438stream_CDLENGULFING};
+static PyObject *__pyx_pw_5talib_7_ta_lib_439stream_CDLENGULFING(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_open = 0;
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_CDLMARUBOZU (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_CDLENGULFING (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 1299, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1299, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1299, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1299, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1299, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLMARUBOZU", 1, 4, 4, 1); __PYX_ERR(3, 1991, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLMARUBOZU", 1, 4, 4, 2); __PYX_ERR(3, 1991, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLMARUBOZU", 1, 4, 4, 3); __PYX_ERR(3, 1991, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_CDLMARUBOZU") < 0)) __PYX_ERR(3, 1991, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLENGULFING", 0) < (0)) __PYX_ERR(5, 1299, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLENGULFING", 1, 4, 4, i); __PYX_ERR(5, 1299, __pyx_L3_error) }
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
+    } else if (unlikely(__pyx_nargs != 4)) {
       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[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1299, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1299, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1299, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1299, __pyx_L3_error)
     }
     __pyx_v_open = ((PyArrayObject *)values[0]);
     __pyx_v_high = ((PyArrayObject *)values[1]);
     __pyx_v_low = ((PyArrayObject *)values[2]);
     __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_CDLMARUBOZU", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 1991, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_CDLENGULFING", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 1299, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLMARUBOZU", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLENGULFING", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 1991, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 1991, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 1991, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 1991, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_470stream_CDLMARUBOZU(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 1301, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 1301, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 1301, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 1301, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_438stream_CDLENGULFING(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_470stream_CDLMARUBOZU(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_438stream_CDLENGULFING(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
   double *__pyx_v_open_data;
@@ -47973,53 +58171,56 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_470stream_CDLMARUBOZU(CYTHON_UNUSED Py
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
-  __Pyx_RefNannySetupContext("stream_CDLMARUBOZU", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_CDLENGULFING", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_open);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2011, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1321, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_open_data = ((double *)__pyx_v_open->data);
+  __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2013, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1323, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_high_data = ((double *)__pyx_v_high->data);
+  __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2015, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1325, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_low_data = ((double *)__pyx_v_low->data);
+  __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2017, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1327, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_close_data = ((double *)__pyx_v_close->data);
+  __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close));
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(3, 2019, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 1329, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
   __pyx_v_outinteger = 0;
 
-  __pyx_v_retCode = TA_CDLMARUBOZU((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
+  __pyx_v_retCode = TA_CDLENGULFING((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLMARUBOZU, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2022, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLENGULFING, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1332, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2023, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1333, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -48029,7 +58230,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_470stream_CDLMARUBOZU(CYTHON_UNUSED Py
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLMARUBOZU", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLENGULFING", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_open);
@@ -48043,99 +58244,146 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_470stream_CDLMARUBOZU(CYTHON_UNUSED Py
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_473stream_CDLMATCHINGLOW(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_472stream_CDLMATCHINGLOW[] = " CDLMATCHINGLOW(open, high, low, close)\n\n    Matching Low (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_473stream_CDLMATCHINGLOW = {"stream_CDLMATCHINGLOW", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_473stream_CDLMATCHINGLOW, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_472stream_CDLMATCHINGLOW};
-static PyObject *__pyx_pw_5talib_7_ta_lib_473stream_CDLMATCHINGLOW(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_441stream_CDLEVENINGDOJISTAR(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_440stream_CDLEVENINGDOJISTAR, "stream_CDLEVENINGDOJISTAR(ndarray open, ndarray high, ndarray low, ndarray close, double penetration=0.3)\n\nCDLEVENINGDOJISTAR(open, high, low, close[, penetration=?])\n\nEvening Doji Star (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nParameters:\n    penetration: 0.3\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_441stream_CDLEVENINGDOJISTAR = {"stream_CDLEVENINGDOJISTAR", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_441stream_CDLEVENINGDOJISTAR, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_440stream_CDLEVENINGDOJISTAR};
+static PyObject *__pyx_pw_5talib_7_ta_lib_441stream_CDLEVENINGDOJISTAR(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_open = 0;
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
+  double __pyx_v_penetration;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[5] = {0,0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_CDLMATCHINGLOW (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_CDLEVENINGDOJISTAR (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,&__pyx_mstate_global->__pyx_n_u_penetration,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 1335, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  5:
+        values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(5, 1335, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1335, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1335, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  0: break;
-        default: goto __pyx_L5_argtuple_error;
-      }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1335, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLMATCHINGLOW", 1, 4, 4, 1); __PYX_ERR(3, 2027, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLMATCHINGLOW", 1, 4, 4, 2); __PYX_ERR(3, 2027, __pyx_L3_error)
-        }
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1335, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLMATCHINGLOW", 1, 4, 4, 3); __PYX_ERR(3, 2027, __pyx_L3_error)
-        }
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
       }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_CDLMATCHINGLOW") < 0)) __PYX_ERR(3, 2027, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLEVENINGDOJISTAR", 0) < (0)) __PYX_ERR(5, 1335, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLEVENINGDOJISTAR", 0, 4, 5, i); __PYX_ERR(5, 1335, __pyx_L3_error) }
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
-      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);
+      switch (__pyx_nargs) {
+        case  5:
+        values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(5, 1335, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1335, __pyx_L3_error)
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1335, __pyx_L3_error)
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1335, __pyx_L3_error)
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1335, __pyx_L3_error)
+        break;
+        default: goto __pyx_L5_argtuple_error;
+      }
     }
     __pyx_v_open = ((PyArrayObject *)values[0]);
     __pyx_v_high = ((PyArrayObject *)values[1]);
     __pyx_v_low = ((PyArrayObject *)values[2]);
     __pyx_v_close = ((PyArrayObject *)values[3]);
+    if (values[4]) {
+      __pyx_v_penetration = __Pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_penetration == (double)-1) && PyErr_Occurred())) __PYX_ERR(5, 1337, __pyx_L3_error)
+    } else {
+      __pyx_v_penetration = ((double)((double)0.3));
+    }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_CDLMATCHINGLOW", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 2027, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_CDLEVENINGDOJISTAR", 0, 4, 5, __pyx_nargs); __PYX_ERR(5, 1335, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLMATCHINGLOW", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLEVENINGDOJISTAR", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 2027, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 2027, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 2027, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 2027, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_472stream_CDLMATCHINGLOW(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 1337, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 1337, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 1337, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 1337, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_440stream_CDLEVENINGDOJISTAR(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_penetration);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_472stream_CDLMATCHINGLOW(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_440stream_CDLEVENINGDOJISTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
   double *__pyx_v_open_data;
@@ -48149,53 +58397,56 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_472stream_CDLMATCHINGLOW(CYTHON_UNUSED
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
-  __Pyx_RefNannySetupContext("stream_CDLMATCHINGLOW", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_CDLEVENINGDOJISTAR", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_open);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2047, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1359, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_open_data = ((double *)__pyx_v_open->data);
+  __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2049, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1361, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_high_data = ((double *)__pyx_v_high->data);
+  __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2051, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1363, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_low_data = ((double *)__pyx_v_low->data);
+  __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2053, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1365, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_close_data = ((double *)__pyx_v_close->data);
+  __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close));
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(3, 2055, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 1367, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
   __pyx_v_outinteger = 0;
 
-  __pyx_v_retCode = TA_CDLMATCHINGLOW((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
+  __pyx_v_retCode = TA_CDLEVENINGDOJISTAR((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, __pyx_v_penetration, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLMATCHINGLOW, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2058, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLEVENINGDOJISTAR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1370, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2059, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1371, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -48205,7 +58456,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_472stream_CDLMATCHINGLOW(CYTHON_UNUSED
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLMATCHINGLOW", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLEVENINGDOJISTAR", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_open);
@@ -48219,79 +58470,95 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_472stream_CDLMATCHINGLOW(CYTHON_UNUSED
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_475stream_CDLMATHOLD(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_474stream_CDLMATHOLD[] = " CDLMATHOLD(open, high, low, close[, penetration=?])\n\n    Mat Hold (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Parameters:\n        penetration: 0.5\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_475stream_CDLMATHOLD = {"stream_CDLMATHOLD", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_475stream_CDLMATHOLD, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_474stream_CDLMATHOLD};
-static PyObject *__pyx_pw_5talib_7_ta_lib_475stream_CDLMATHOLD(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_443stream_CDLEVENINGSTAR(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_442stream_CDLEVENINGSTAR, "stream_CDLEVENINGSTAR(ndarray open, ndarray high, ndarray low, ndarray close, double penetration=0.3)\n\nCDLEVENINGSTAR(open, high, low, close[, penetration=?])\n\nEvening Star (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nParameters:\n    penetration: 0.3\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_443stream_CDLEVENINGSTAR = {"stream_CDLEVENINGSTAR", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_443stream_CDLEVENINGSTAR, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_442stream_CDLEVENINGSTAR};
+static PyObject *__pyx_pw_5talib_7_ta_lib_443stream_CDLEVENINGSTAR(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_open = 0;
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
   double __pyx_v_penetration;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[5] = {0,0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_CDLMATHOLD (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_CDLEVENINGSTAR (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,&__pyx_n_s_penetration,0};
-    PyObject* values[5] = {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  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,&__pyx_mstate_global->__pyx_n_u_penetration,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 1373, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  5:
+        values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(5, 1373, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1373, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1373, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1373, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1373, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLMATHOLD", 0, 4, 5, 1); __PYX_ERR(3, 2063, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLMATHOLD", 0, 4, 5, 2); __PYX_ERR(3, 2063, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLMATHOLD", 0, 4, 5, 3); __PYX_ERR(3, 2063, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  4:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_penetration);
-          if (value) { values[4] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_CDLMATHOLD") < 0)) __PYX_ERR(3, 2063, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLEVENINGSTAR", 0) < (0)) __PYX_ERR(5, 1373, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLEVENINGSTAR", 0, 4, 5, i); __PYX_ERR(5, 1373, __pyx_L3_error) }
       }
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
+      switch (__pyx_nargs) {
+        case  5:
+        values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(5, 1373, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1373, __pyx_L3_error)
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1373, __pyx_L3_error)
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1373, __pyx_L3_error)
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1373, __pyx_L3_error)
         break;
         default: goto __pyx_L5_argtuple_error;
       }
@@ -48301,35 +58568,48 @@ static PyObject *__pyx_pw_5talib_7_ta_lib_475stream_CDLMATHOLD(PyObject *__pyx_s
     __pyx_v_low = ((PyArrayObject *)values[2]);
     __pyx_v_close = ((PyArrayObject *)values[3]);
     if (values[4]) {
-      __pyx_v_penetration = __pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_penetration == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 2063, __pyx_L3_error)
+      __pyx_v_penetration = __Pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_penetration == (double)-1) && PyErr_Occurred())) __PYX_ERR(5, 1375, __pyx_L3_error)
     } else {
-      __pyx_v_penetration = ((double)0.5);
+      __pyx_v_penetration = ((double)((double)0.3));
     }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_CDLMATHOLD", 0, 4, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 2063, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_CDLEVENINGSTAR", 0, 4, 5, __pyx_nargs); __PYX_ERR(5, 1373, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLMATHOLD", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLEVENINGSTAR", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 2063, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 2063, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 2063, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 2063, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_474stream_CDLMATHOLD(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_penetration);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 1375, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 1375, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 1375, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 1375, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_442stream_CDLEVENINGSTAR(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_penetration);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_474stream_CDLMATHOLD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_442stream_CDLEVENINGSTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
   double *__pyx_v_open_data;
@@ -48343,53 +58623,56 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_474stream_CDLMATHOLD(CYTHON_UNUSED PyO
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
-  __Pyx_RefNannySetupContext("stream_CDLMATHOLD", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_CDLEVENINGSTAR", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_open);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2085, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1397, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_open_data = ((double *)__pyx_v_open->data);
+  __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2087, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1399, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_high_data = ((double *)__pyx_v_high->data);
+  __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2089, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1401, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_low_data = ((double *)__pyx_v_low->data);
+  __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2091, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1403, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_close_data = ((double *)__pyx_v_close->data);
+  __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close));
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(3, 2093, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 1405, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
   __pyx_v_outinteger = 0;
 
-  __pyx_v_retCode = TA_CDLMATHOLD((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, __pyx_v_penetration, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
+  __pyx_v_retCode = TA_CDLEVENINGSTAR((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, __pyx_v_penetration, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLMATHOLD, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2096, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLEVENINGSTAR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1408, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2097, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1409, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -48399,7 +58682,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_474stream_CDLMATHOLD(CYTHON_UNUSED PyO
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLMATHOLD", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLEVENINGSTAR", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_open);
@@ -48413,117 +58696,129 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_474stream_CDLMATHOLD(CYTHON_UNUSED PyO
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_477stream_CDLMORNINGDOJISTAR(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_476stream_CDLMORNINGDOJISTAR[] = " CDLMORNINGDOJISTAR(open, high, low, close[, penetration=?])\n\n    Morning Doji Star (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Parameters:\n        penetration: 0.3\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_477stream_CDLMORNINGDOJISTAR = {"stream_CDLMORNINGDOJISTAR", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_477stream_CDLMORNINGDOJISTAR, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_476stream_CDLMORNINGDOJISTAR};
-static PyObject *__pyx_pw_5talib_7_ta_lib_477stream_CDLMORNINGDOJISTAR(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_445stream_CDLGAPSIDESIDEWHITE(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_444stream_CDLGAPSIDESIDEWHITE, "stream_CDLGAPSIDESIDEWHITE(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLGAPSIDESIDEWHITE(open, high, low, close)\n\nUp/Down-gap side-by-side white lines (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_445stream_CDLGAPSIDESIDEWHITE = {"stream_CDLGAPSIDESIDEWHITE", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_445stream_CDLGAPSIDESIDEWHITE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_444stream_CDLGAPSIDESIDEWHITE};
+static PyObject *__pyx_pw_5talib_7_ta_lib_445stream_CDLGAPSIDESIDEWHITE(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_open = 0;
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
-  double __pyx_v_penetration;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_CDLMORNINGDOJISTAR (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_CDLGAPSIDESIDEWHITE (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,&__pyx_n_s_penetration,0};
-    PyObject* values[5] = {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  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
-        CYTHON_FALLTHROUGH;
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 1411, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1411, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1411, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1411, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1411, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLMORNINGDOJISTAR", 0, 4, 5, 1); __PYX_ERR(3, 2101, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLMORNINGDOJISTAR", 0, 4, 5, 2); __PYX_ERR(3, 2101, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLMORNINGDOJISTAR", 0, 4, 5, 3); __PYX_ERR(3, 2101, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  4:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_penetration);
-          if (value) { values[4] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_CDLMORNINGDOJISTAR") < 0)) __PYX_ERR(3, 2101, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLGAPSIDESIDEWHITE", 0) < (0)) __PYX_ERR(5, 1411, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLGAPSIDESIDEWHITE", 1, 4, 4, i); __PYX_ERR(5, 1411, __pyx_L3_error) }
       }
+    } else if (unlikely(__pyx_nargs != 4)) {
+      goto __pyx_L5_argtuple_error;
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
-        CYTHON_FALLTHROUGH;
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-        break;
-        default: goto __pyx_L5_argtuple_error;
-      }
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1411, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1411, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1411, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1411, __pyx_L3_error)
     }
     __pyx_v_open = ((PyArrayObject *)values[0]);
     __pyx_v_high = ((PyArrayObject *)values[1]);
     __pyx_v_low = ((PyArrayObject *)values[2]);
     __pyx_v_close = ((PyArrayObject *)values[3]);
-    if (values[4]) {
-      __pyx_v_penetration = __pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_penetration == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 2101, __pyx_L3_error)
-    } else {
-      __pyx_v_penetration = ((double)0.3);
-    }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_CDLMORNINGDOJISTAR", 0, 4, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 2101, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_CDLGAPSIDESIDEWHITE", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 1411, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLMORNINGDOJISTAR", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLGAPSIDESIDEWHITE", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 2101, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 2101, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 2101, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 2101, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_476stream_CDLMORNINGDOJISTAR(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_penetration);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 1413, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 1413, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 1413, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 1413, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_444stream_CDLGAPSIDESIDEWHITE(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_476stream_CDLMORNINGDOJISTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_444stream_CDLGAPSIDESIDEWHITE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
   double *__pyx_v_open_data;
@@ -48537,53 +58832,56 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_476stream_CDLMORNINGDOJISTAR(CYTHON_UN
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
-  __Pyx_RefNannySetupContext("stream_CDLMORNINGDOJISTAR", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_CDLGAPSIDESIDEWHITE", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_open);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2123, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1433, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_open_data = ((double *)__pyx_v_open->data);
+  __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2125, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1435, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_high_data = ((double *)__pyx_v_high->data);
+  __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2127, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1437, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_low_data = ((double *)__pyx_v_low->data);
+  __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2129, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1439, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_close_data = ((double *)__pyx_v_close->data);
+  __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close));
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(3, 2131, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 1441, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
   __pyx_v_outinteger = 0;
 
-  __pyx_v_retCode = TA_CDLMORNINGDOJISTAR((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, __pyx_v_penetration, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
+  __pyx_v_retCode = TA_CDLGAPSIDESIDEWHITE((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLMORNINGDOJISTAR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2134, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLGAPSIDESIDEWHITE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1444, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2135, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1445, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -48593,7 +58891,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_476stream_CDLMORNINGDOJISTAR(CYTHON_UN
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLMORNINGDOJISTAR", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLGAPSIDESIDEWHITE", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_open);
@@ -48607,117 +58905,129 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_476stream_CDLMORNINGDOJISTAR(CYTHON_UN
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_479stream_CDLMORNINGSTAR(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_478stream_CDLMORNINGSTAR[] = " CDLMORNINGSTAR(open, high, low, close[, penetration=?])\n\n    Morning Star (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Parameters:\n        penetration: 0.3\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_479stream_CDLMORNINGSTAR = {"stream_CDLMORNINGSTAR", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_479stream_CDLMORNINGSTAR, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_478stream_CDLMORNINGSTAR};
-static PyObject *__pyx_pw_5talib_7_ta_lib_479stream_CDLMORNINGSTAR(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_447stream_CDLGRAVESTONEDOJI(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_446stream_CDLGRAVESTONEDOJI, "stream_CDLGRAVESTONEDOJI(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLGRAVESTONEDOJI(open, high, low, close)\n\nGravestone Doji (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_447stream_CDLGRAVESTONEDOJI = {"stream_CDLGRAVESTONEDOJI", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_447stream_CDLGRAVESTONEDOJI, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_446stream_CDLGRAVESTONEDOJI};
+static PyObject *__pyx_pw_5talib_7_ta_lib_447stream_CDLGRAVESTONEDOJI(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_open = 0;
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
-  double __pyx_v_penetration;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_CDLMORNINGSTAR (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_CDLGRAVESTONEDOJI (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,&__pyx_n_s_penetration,0};
-    PyObject* values[5] = {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  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
-        CYTHON_FALLTHROUGH;
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 1447, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1447, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1447, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1447, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1447, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLMORNINGSTAR", 0, 4, 5, 1); __PYX_ERR(3, 2139, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLMORNINGSTAR", 0, 4, 5, 2); __PYX_ERR(3, 2139, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLMORNINGSTAR", 0, 4, 5, 3); __PYX_ERR(3, 2139, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  4:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_penetration);
-          if (value) { values[4] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_CDLMORNINGSTAR") < 0)) __PYX_ERR(3, 2139, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLGRAVESTONEDOJI", 0) < (0)) __PYX_ERR(5, 1447, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLGRAVESTONEDOJI", 1, 4, 4, i); __PYX_ERR(5, 1447, __pyx_L3_error) }
       }
+    } else if (unlikely(__pyx_nargs != 4)) {
+      goto __pyx_L5_argtuple_error;
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
-        CYTHON_FALLTHROUGH;
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-        break;
-        default: goto __pyx_L5_argtuple_error;
-      }
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1447, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1447, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1447, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1447, __pyx_L3_error)
     }
     __pyx_v_open = ((PyArrayObject *)values[0]);
     __pyx_v_high = ((PyArrayObject *)values[1]);
     __pyx_v_low = ((PyArrayObject *)values[2]);
     __pyx_v_close = ((PyArrayObject *)values[3]);
-    if (values[4]) {
-      __pyx_v_penetration = __pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_penetration == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 2139, __pyx_L3_error)
-    } else {
-      __pyx_v_penetration = ((double)0.3);
-    }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_CDLMORNINGSTAR", 0, 4, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 2139, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_CDLGRAVESTONEDOJI", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 1447, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLMORNINGSTAR", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLGRAVESTONEDOJI", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 2139, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 2139, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 2139, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 2139, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_478stream_CDLMORNINGSTAR(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_penetration);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 1449, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 1449, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 1449, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 1449, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_446stream_CDLGRAVESTONEDOJI(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_478stream_CDLMORNINGSTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_446stream_CDLGRAVESTONEDOJI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
   double *__pyx_v_open_data;
@@ -48731,53 +59041,56 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_478stream_CDLMORNINGSTAR(CYTHON_UNUSED
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
-  __Pyx_RefNannySetupContext("stream_CDLMORNINGSTAR", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_CDLGRAVESTONEDOJI", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_open);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2161, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1469, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_open_data = ((double *)__pyx_v_open->data);
+  __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2163, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1471, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_high_data = ((double *)__pyx_v_high->data);
+  __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2165, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1473, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_low_data = ((double *)__pyx_v_low->data);
+  __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2167, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1475, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_close_data = ((double *)__pyx_v_close->data);
+  __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close));
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(3, 2169, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 1477, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
   __pyx_v_outinteger = 0;
 
-  __pyx_v_retCode = TA_CDLMORNINGSTAR((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, __pyx_v_penetration, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
+  __pyx_v_retCode = TA_CDLGRAVESTONEDOJI((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLMORNINGSTAR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2172, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLGRAVESTONEDOJI, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1480, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2173, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1481, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -48787,7 +59100,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_478stream_CDLMORNINGSTAR(CYTHON_UNUSED
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLMORNINGSTAR", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLGRAVESTONEDOJI", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_open);
@@ -48801,99 +59114,129 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_478stream_CDLMORNINGSTAR(CYTHON_UNUSED
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_481stream_CDLONNECK(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_480stream_CDLONNECK[] = " CDLONNECK(open, high, low, close)\n\n    On-Neck Pattern (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_481stream_CDLONNECK = {"stream_CDLONNECK", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_481stream_CDLONNECK, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_480stream_CDLONNECK};
-static PyObject *__pyx_pw_5talib_7_ta_lib_481stream_CDLONNECK(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_449stream_CDLHAMMER(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_448stream_CDLHAMMER, "stream_CDLHAMMER(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLHAMMER(open, high, low, close)\n\nHammer (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_449stream_CDLHAMMER = {"stream_CDLHAMMER", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_449stream_CDLHAMMER, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_448stream_CDLHAMMER};
+static PyObject *__pyx_pw_5talib_7_ta_lib_449stream_CDLHAMMER(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_open = 0;
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_CDLONNECK (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_CDLHAMMER (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 1483, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1483, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1483, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1483, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1483, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLONNECK", 1, 4, 4, 1); __PYX_ERR(3, 2177, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLONNECK", 1, 4, 4, 2); __PYX_ERR(3, 2177, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLONNECK", 1, 4, 4, 3); __PYX_ERR(3, 2177, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_CDLONNECK") < 0)) __PYX_ERR(3, 2177, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLHAMMER", 0) < (0)) __PYX_ERR(5, 1483, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLHAMMER", 1, 4, 4, i); __PYX_ERR(5, 1483, __pyx_L3_error) }
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
+    } else if (unlikely(__pyx_nargs != 4)) {
       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[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1483, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1483, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1483, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1483, __pyx_L3_error)
     }
     __pyx_v_open = ((PyArrayObject *)values[0]);
     __pyx_v_high = ((PyArrayObject *)values[1]);
     __pyx_v_low = ((PyArrayObject *)values[2]);
     __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_CDLONNECK", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 2177, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_CDLHAMMER", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 1483, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLONNECK", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLHAMMER", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 2177, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 2177, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 2177, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 2177, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_480stream_CDLONNECK(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 1485, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 1485, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 1485, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 1485, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_448stream_CDLHAMMER(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_480stream_CDLONNECK(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_448stream_CDLHAMMER(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
   double *__pyx_v_open_data;
@@ -48907,53 +59250,56 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_480stream_CDLONNECK(CYTHON_UNUSED PyOb
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
-  __Pyx_RefNannySetupContext("stream_CDLONNECK", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_CDLHAMMER", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_open);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2197, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1505, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_open_data = ((double *)__pyx_v_open->data);
+  __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2199, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1507, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_high_data = ((double *)__pyx_v_high->data);
+  __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2201, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1509, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_low_data = ((double *)__pyx_v_low->data);
+  __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2203, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1511, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_close_data = ((double *)__pyx_v_close->data);
+  __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close));
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(3, 2205, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 1513, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
   __pyx_v_outinteger = 0;
 
-  __pyx_v_retCode = TA_CDLONNECK((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
+  __pyx_v_retCode = TA_CDLHAMMER((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLONNECK, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2208, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLHAMMER, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1516, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2209, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1517, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -48963,7 +59309,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_480stream_CDLONNECK(CYTHON_UNUSED PyOb
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLONNECK", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLHAMMER", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_open);
@@ -48977,99 +59323,129 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_480stream_CDLONNECK(CYTHON_UNUSED PyOb
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_483stream_CDLPIERCING(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_482stream_CDLPIERCING[] = " CDLPIERCING(open, high, low, close)\n\n    Piercing Pattern (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_483stream_CDLPIERCING = {"stream_CDLPIERCING", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_483stream_CDLPIERCING, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_482stream_CDLPIERCING};
-static PyObject *__pyx_pw_5talib_7_ta_lib_483stream_CDLPIERCING(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_451stream_CDLHANGINGMAN(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_450stream_CDLHANGINGMAN, "stream_CDLHANGINGMAN(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLHANGINGMAN(open, high, low, close)\n\nHanging Man (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_451stream_CDLHANGINGMAN = {"stream_CDLHANGINGMAN", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_451stream_CDLHANGINGMAN, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_450stream_CDLHANGINGMAN};
+static PyObject *__pyx_pw_5talib_7_ta_lib_451stream_CDLHANGINGMAN(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_open = 0;
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_CDLPIERCING (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_CDLHANGINGMAN (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 1519, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1519, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1519, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1519, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1519, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLPIERCING", 1, 4, 4, 1); __PYX_ERR(3, 2213, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLPIERCING", 1, 4, 4, 2); __PYX_ERR(3, 2213, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLPIERCING", 1, 4, 4, 3); __PYX_ERR(3, 2213, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_CDLPIERCING") < 0)) __PYX_ERR(3, 2213, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLHANGINGMAN", 0) < (0)) __PYX_ERR(5, 1519, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLHANGINGMAN", 1, 4, 4, i); __PYX_ERR(5, 1519, __pyx_L3_error) }
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
+    } else if (unlikely(__pyx_nargs != 4)) {
       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[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1519, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1519, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1519, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1519, __pyx_L3_error)
     }
     __pyx_v_open = ((PyArrayObject *)values[0]);
     __pyx_v_high = ((PyArrayObject *)values[1]);
     __pyx_v_low = ((PyArrayObject *)values[2]);
     __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_CDLPIERCING", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 2213, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_CDLHANGINGMAN", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 1519, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLPIERCING", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLHANGINGMAN", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 2213, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 2213, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 2213, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 2213, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_482stream_CDLPIERCING(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 1521, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 1521, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 1521, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 1521, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_450stream_CDLHANGINGMAN(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_482stream_CDLPIERCING(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_450stream_CDLHANGINGMAN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
   double *__pyx_v_open_data;
@@ -49083,53 +59459,56 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_482stream_CDLPIERCING(CYTHON_UNUSED Py
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
-  __Pyx_RefNannySetupContext("stream_CDLPIERCING", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_CDLHANGINGMAN", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_open);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2233, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1541, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_open_data = ((double *)__pyx_v_open->data);
+  __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2235, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1543, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_high_data = ((double *)__pyx_v_high->data);
+  __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2237, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1545, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_low_data = ((double *)__pyx_v_low->data);
+  __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2239, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1547, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_close_data = ((double *)__pyx_v_close->data);
+  __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close));
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(3, 2241, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 1549, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
   __pyx_v_outinteger = 0;
 
-  __pyx_v_retCode = TA_CDLPIERCING((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
+  __pyx_v_retCode = TA_CDLHANGINGMAN((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLPIERCING, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2244, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLHANGINGMAN, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1552, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2245, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1553, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -49139,7 +59518,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_482stream_CDLPIERCING(CYTHON_UNUSED Py
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLPIERCING", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLHANGINGMAN", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_open);
@@ -49153,99 +59532,129 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_482stream_CDLPIERCING(CYTHON_UNUSED Py
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_485stream_CDLRICKSHAWMAN(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_484stream_CDLRICKSHAWMAN[] = " CDLRICKSHAWMAN(open, high, low, close)\n\n    Rickshaw Man (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_485stream_CDLRICKSHAWMAN = {"stream_CDLRICKSHAWMAN", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_485stream_CDLRICKSHAWMAN, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_484stream_CDLRICKSHAWMAN};
-static PyObject *__pyx_pw_5talib_7_ta_lib_485stream_CDLRICKSHAWMAN(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_453stream_CDLHARAMI(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_452stream_CDLHARAMI, "stream_CDLHARAMI(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLHARAMI(open, high, low, close)\n\nHarami Pattern (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_453stream_CDLHARAMI = {"stream_CDLHARAMI", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_453stream_CDLHARAMI, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_452stream_CDLHARAMI};
+static PyObject *__pyx_pw_5talib_7_ta_lib_453stream_CDLHARAMI(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_open = 0;
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_CDLRICKSHAWMAN (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_CDLHARAMI (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 1555, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1555, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1555, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1555, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1555, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLRICKSHAWMAN", 1, 4, 4, 1); __PYX_ERR(3, 2249, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLRICKSHAWMAN", 1, 4, 4, 2); __PYX_ERR(3, 2249, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLRICKSHAWMAN", 1, 4, 4, 3); __PYX_ERR(3, 2249, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_CDLRICKSHAWMAN") < 0)) __PYX_ERR(3, 2249, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLHARAMI", 0) < (0)) __PYX_ERR(5, 1555, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLHARAMI", 1, 4, 4, i); __PYX_ERR(5, 1555, __pyx_L3_error) }
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
+    } else if (unlikely(__pyx_nargs != 4)) {
       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[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1555, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1555, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1555, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1555, __pyx_L3_error)
     }
     __pyx_v_open = ((PyArrayObject *)values[0]);
     __pyx_v_high = ((PyArrayObject *)values[1]);
     __pyx_v_low = ((PyArrayObject *)values[2]);
     __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_CDLRICKSHAWMAN", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 2249, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_CDLHARAMI", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 1555, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLRICKSHAWMAN", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLHARAMI", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 2249, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 2249, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 2249, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 2249, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_484stream_CDLRICKSHAWMAN(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 1557, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 1557, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 1557, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 1557, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_452stream_CDLHARAMI(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_484stream_CDLRICKSHAWMAN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_452stream_CDLHARAMI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
   double *__pyx_v_open_data;
@@ -49259,53 +59668,56 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_484stream_CDLRICKSHAWMAN(CYTHON_UNUSED
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
-  __Pyx_RefNannySetupContext("stream_CDLRICKSHAWMAN", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_CDLHARAMI", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_open);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2269, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1577, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_open_data = ((double *)__pyx_v_open->data);
+  __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2271, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1579, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_high_data = ((double *)__pyx_v_high->data);
+  __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2273, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1581, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_low_data = ((double *)__pyx_v_low->data);
+  __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2275, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1583, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_close_data = ((double *)__pyx_v_close->data);
+  __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close));
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(3, 2277, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 1585, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
   __pyx_v_outinteger = 0;
 
-  __pyx_v_retCode = TA_CDLRICKSHAWMAN((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
+  __pyx_v_retCode = TA_CDLHARAMI((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLRICKSHAWMAN, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2280, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLHARAMI, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1588, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2281, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1589, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -49315,7 +59727,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_484stream_CDLRICKSHAWMAN(CYTHON_UNUSED
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLRICKSHAWMAN", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLHARAMI", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_open);
@@ -49329,99 +59741,129 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_484stream_CDLRICKSHAWMAN(CYTHON_UNUSED
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_487stream_CDLRISEFALL3METHODS(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_486stream_CDLRISEFALL3METHODS[] = " CDLRISEFALL3METHODS(open, high, low, close)\n\n    Rising/Falling Three Methods (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_487stream_CDLRISEFALL3METHODS = {"stream_CDLRISEFALL3METHODS", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_487stream_CDLRISEFALL3METHODS, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_486stream_CDLRISEFALL3METHODS};
-static PyObject *__pyx_pw_5talib_7_ta_lib_487stream_CDLRISEFALL3METHODS(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_455stream_CDLHARAMICROSS(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_454stream_CDLHARAMICROSS, "stream_CDLHARAMICROSS(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLHARAMICROSS(open, high, low, close)\n\nHarami Cross Pattern (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_455stream_CDLHARAMICROSS = {"stream_CDLHARAMICROSS", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_455stream_CDLHARAMICROSS, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_454stream_CDLHARAMICROSS};
+static PyObject *__pyx_pw_5talib_7_ta_lib_455stream_CDLHARAMICROSS(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_open = 0;
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_CDLRISEFALL3METHODS (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_CDLHARAMICROSS (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 1591, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1591, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1591, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1591, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1591, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLRISEFALL3METHODS", 1, 4, 4, 1); __PYX_ERR(3, 2285, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLRISEFALL3METHODS", 1, 4, 4, 2); __PYX_ERR(3, 2285, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLRISEFALL3METHODS", 1, 4, 4, 3); __PYX_ERR(3, 2285, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_CDLRISEFALL3METHODS") < 0)) __PYX_ERR(3, 2285, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLHARAMICROSS", 0) < (0)) __PYX_ERR(5, 1591, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLHARAMICROSS", 1, 4, 4, i); __PYX_ERR(5, 1591, __pyx_L3_error) }
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
+    } else if (unlikely(__pyx_nargs != 4)) {
       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[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1591, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1591, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1591, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1591, __pyx_L3_error)
     }
     __pyx_v_open = ((PyArrayObject *)values[0]);
     __pyx_v_high = ((PyArrayObject *)values[1]);
     __pyx_v_low = ((PyArrayObject *)values[2]);
     __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_CDLRISEFALL3METHODS", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 2285, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_CDLHARAMICROSS", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 1591, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLRISEFALL3METHODS", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLHARAMICROSS", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 2285, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 2285, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 2285, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 2285, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_486stream_CDLRISEFALL3METHODS(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 1593, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 1593, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 1593, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 1593, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_454stream_CDLHARAMICROSS(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_486stream_CDLRISEFALL3METHODS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_454stream_CDLHARAMICROSS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
   double *__pyx_v_open_data;
@@ -49435,53 +59877,56 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_486stream_CDLRISEFALL3METHODS(CYTHON_U
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
-  __Pyx_RefNannySetupContext("stream_CDLRISEFALL3METHODS", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_CDLHARAMICROSS", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_open);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2305, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1613, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_open_data = ((double *)__pyx_v_open->data);
+  __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2307, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1615, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_high_data = ((double *)__pyx_v_high->data);
+  __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2309, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1617, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_low_data = ((double *)__pyx_v_low->data);
+  __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2311, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1619, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_close_data = ((double *)__pyx_v_close->data);
+  __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close));
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(3, 2313, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 1621, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
   __pyx_v_outinteger = 0;
 
-  __pyx_v_retCode = TA_CDLRISEFALL3METHODS((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
+  __pyx_v_retCode = TA_CDLHARAMICROSS((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLRISEFALL3METHODS, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2316, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLHARAMICROSS, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1624, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2317, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1625, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -49491,7 +59936,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_486stream_CDLRISEFALL3METHODS(CYTHON_U
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLRISEFALL3METHODS", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLHARAMICROSS", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_open);
@@ -49505,99 +59950,129 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_486stream_CDLRISEFALL3METHODS(CYTHON_U
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_489stream_CDLSEPARATINGLINES(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_488stream_CDLSEPARATINGLINES[] = " CDLSEPARATINGLINES(open, high, low, close)\n\n    Separating Lines (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_489stream_CDLSEPARATINGLINES = {"stream_CDLSEPARATINGLINES", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_489stream_CDLSEPARATINGLINES, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_488stream_CDLSEPARATINGLINES};
-static PyObject *__pyx_pw_5talib_7_ta_lib_489stream_CDLSEPARATINGLINES(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_457stream_CDLHIGHWAVE(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_456stream_CDLHIGHWAVE, "stream_CDLHIGHWAVE(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLHIGHWAVE(open, high, low, close)\n\nHigh-Wave Candle (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_457stream_CDLHIGHWAVE = {"stream_CDLHIGHWAVE", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_457stream_CDLHIGHWAVE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_456stream_CDLHIGHWAVE};
+static PyObject *__pyx_pw_5talib_7_ta_lib_457stream_CDLHIGHWAVE(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_open = 0;
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_CDLSEPARATINGLINES (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_CDLHIGHWAVE (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 1627, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1627, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1627, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1627, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1627, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLSEPARATINGLINES", 1, 4, 4, 1); __PYX_ERR(3, 2321, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLSEPARATINGLINES", 1, 4, 4, 2); __PYX_ERR(3, 2321, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLSEPARATINGLINES", 1, 4, 4, 3); __PYX_ERR(3, 2321, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_CDLSEPARATINGLINES") < 0)) __PYX_ERR(3, 2321, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLHIGHWAVE", 0) < (0)) __PYX_ERR(5, 1627, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLHIGHWAVE", 1, 4, 4, i); __PYX_ERR(5, 1627, __pyx_L3_error) }
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
+    } else if (unlikely(__pyx_nargs != 4)) {
       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[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1627, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1627, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1627, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1627, __pyx_L3_error)
     }
     __pyx_v_open = ((PyArrayObject *)values[0]);
     __pyx_v_high = ((PyArrayObject *)values[1]);
     __pyx_v_low = ((PyArrayObject *)values[2]);
     __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_CDLSEPARATINGLINES", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 2321, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_CDLHIGHWAVE", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 1627, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLSEPARATINGLINES", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLHIGHWAVE", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 2321, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 2321, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 2321, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 2321, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_488stream_CDLSEPARATINGLINES(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 1629, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 1629, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 1629, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 1629, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_456stream_CDLHIGHWAVE(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_488stream_CDLSEPARATINGLINES(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_456stream_CDLHIGHWAVE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
   double *__pyx_v_open_data;
@@ -49611,53 +60086,56 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_488stream_CDLSEPARATINGLINES(CYTHON_UN
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
-  __Pyx_RefNannySetupContext("stream_CDLSEPARATINGLINES", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_CDLHIGHWAVE", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_open);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2341, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1649, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_open_data = ((double *)__pyx_v_open->data);
+  __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2343, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1651, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_high_data = ((double *)__pyx_v_high->data);
+  __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2345, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1653, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_low_data = ((double *)__pyx_v_low->data);
+  __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2347, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1655, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_close_data = ((double *)__pyx_v_close->data);
+  __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close));
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(3, 2349, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 1657, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
   __pyx_v_outinteger = 0;
 
-  __pyx_v_retCode = TA_CDLSEPARATINGLINES((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
+  __pyx_v_retCode = TA_CDLHIGHWAVE((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLSEPARATINGLINES, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2352, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLHIGHWAVE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1660, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2353, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1661, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -49667,7 +60145,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_488stream_CDLSEPARATINGLINES(CYTHON_UN
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLSEPARATINGLINES", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLHIGHWAVE", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_open);
@@ -49681,99 +60159,129 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_488stream_CDLSEPARATINGLINES(CYTHON_UN
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_491stream_CDLSHOOTINGSTAR(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_490stream_CDLSHOOTINGSTAR[] = " CDLSHOOTINGSTAR(open, high, low, close)\n\n    Shooting Star (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_491stream_CDLSHOOTINGSTAR = {"stream_CDLSHOOTINGSTAR", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_491stream_CDLSHOOTINGSTAR, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_490stream_CDLSHOOTINGSTAR};
-static PyObject *__pyx_pw_5talib_7_ta_lib_491stream_CDLSHOOTINGSTAR(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_459stream_CDLHIKKAKE(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_458stream_CDLHIKKAKE, "stream_CDLHIKKAKE(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLHIKKAKE(open, high, low, close)\n\nHikkake Pattern (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_459stream_CDLHIKKAKE = {"stream_CDLHIKKAKE", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_459stream_CDLHIKKAKE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_458stream_CDLHIKKAKE};
+static PyObject *__pyx_pw_5talib_7_ta_lib_459stream_CDLHIKKAKE(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_open = 0;
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_CDLSHOOTINGSTAR (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_CDLHIKKAKE (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 1663, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1663, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1663, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1663, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1663, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLSHOOTINGSTAR", 1, 4, 4, 1); __PYX_ERR(3, 2357, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLSHOOTINGSTAR", 1, 4, 4, 2); __PYX_ERR(3, 2357, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLSHOOTINGSTAR", 1, 4, 4, 3); __PYX_ERR(3, 2357, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_CDLSHOOTINGSTAR") < 0)) __PYX_ERR(3, 2357, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLHIKKAKE", 0) < (0)) __PYX_ERR(5, 1663, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLHIKKAKE", 1, 4, 4, i); __PYX_ERR(5, 1663, __pyx_L3_error) }
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
+    } else if (unlikely(__pyx_nargs != 4)) {
       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[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1663, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1663, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1663, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1663, __pyx_L3_error)
     }
     __pyx_v_open = ((PyArrayObject *)values[0]);
     __pyx_v_high = ((PyArrayObject *)values[1]);
     __pyx_v_low = ((PyArrayObject *)values[2]);
     __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_CDLSHOOTINGSTAR", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 2357, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_CDLHIKKAKE", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 1663, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLSHOOTINGSTAR", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLHIKKAKE", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 2357, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 2357, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 2357, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 2357, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_490stream_CDLSHOOTINGSTAR(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 1665, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 1665, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 1665, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 1665, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_458stream_CDLHIKKAKE(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_490stream_CDLSHOOTINGSTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_458stream_CDLHIKKAKE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
   double *__pyx_v_open_data;
@@ -49787,53 +60295,56 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_490stream_CDLSHOOTINGSTAR(CYTHON_UNUSE
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
-  __Pyx_RefNannySetupContext("stream_CDLSHOOTINGSTAR", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_CDLHIKKAKE", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_open);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2377, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1685, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_open_data = ((double *)__pyx_v_open->data);
+  __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2379, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1687, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_high_data = ((double *)__pyx_v_high->data);
+  __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2381, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1689, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_low_data = ((double *)__pyx_v_low->data);
+  __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2383, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1691, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_close_data = ((double *)__pyx_v_close->data);
+  __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close));
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(3, 2385, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 1693, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
   __pyx_v_outinteger = 0;
 
-  __pyx_v_retCode = TA_CDLSHOOTINGSTAR((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
+  __pyx_v_retCode = TA_CDLHIKKAKE((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLSHOOTINGSTAR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2388, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLHIKKAKE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1696, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2389, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1697, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -49843,7 +60354,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_490stream_CDLSHOOTINGSTAR(CYTHON_UNUSE
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLSHOOTINGSTAR", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLHIKKAKE", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_open);
@@ -49857,99 +60368,129 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_490stream_CDLSHOOTINGSTAR(CYTHON_UNUSE
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_493stream_CDLSHORTLINE(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_492stream_CDLSHORTLINE[] = " CDLSHORTLINE(open, high, low, close)\n\n    Short Line Candle (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_493stream_CDLSHORTLINE = {"stream_CDLSHORTLINE", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_493stream_CDLSHORTLINE, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_492stream_CDLSHORTLINE};
-static PyObject *__pyx_pw_5talib_7_ta_lib_493stream_CDLSHORTLINE(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_461stream_CDLHIKKAKEMOD(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_460stream_CDLHIKKAKEMOD, "stream_CDLHIKKAKEMOD(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLHIKKAKEMOD(open, high, low, close)\n\nModified Hikkake Pattern (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_461stream_CDLHIKKAKEMOD = {"stream_CDLHIKKAKEMOD", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_461stream_CDLHIKKAKEMOD, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_460stream_CDLHIKKAKEMOD};
+static PyObject *__pyx_pw_5talib_7_ta_lib_461stream_CDLHIKKAKEMOD(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_open = 0;
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_CDLSHORTLINE (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_CDLHIKKAKEMOD (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 1699, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1699, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1699, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1699, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1699, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLSHORTLINE", 1, 4, 4, 1); __PYX_ERR(3, 2393, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLSHORTLINE", 1, 4, 4, 2); __PYX_ERR(3, 2393, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLSHORTLINE", 1, 4, 4, 3); __PYX_ERR(3, 2393, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_CDLSHORTLINE") < 0)) __PYX_ERR(3, 2393, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLHIKKAKEMOD", 0) < (0)) __PYX_ERR(5, 1699, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLHIKKAKEMOD", 1, 4, 4, i); __PYX_ERR(5, 1699, __pyx_L3_error) }
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
+    } else if (unlikely(__pyx_nargs != 4)) {
       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[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1699, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1699, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1699, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1699, __pyx_L3_error)
     }
     __pyx_v_open = ((PyArrayObject *)values[0]);
     __pyx_v_high = ((PyArrayObject *)values[1]);
     __pyx_v_low = ((PyArrayObject *)values[2]);
     __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_CDLSHORTLINE", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 2393, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_CDLHIKKAKEMOD", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 1699, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLSHORTLINE", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLHIKKAKEMOD", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 2393, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 2393, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 2393, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 2393, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_492stream_CDLSHORTLINE(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 1701, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 1701, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 1701, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 1701, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_460stream_CDLHIKKAKEMOD(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_492stream_CDLSHORTLINE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_460stream_CDLHIKKAKEMOD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
   double *__pyx_v_open_data;
@@ -49963,53 +60504,56 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_492stream_CDLSHORTLINE(CYTHON_UNUSED P
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
-  __Pyx_RefNannySetupContext("stream_CDLSHORTLINE", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_CDLHIKKAKEMOD", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_open);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2413, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1721, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_open_data = ((double *)__pyx_v_open->data);
+  __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2415, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1723, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_high_data = ((double *)__pyx_v_high->data);
+  __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2417, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1725, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_low_data = ((double *)__pyx_v_low->data);
+  __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2419, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1727, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_close_data = ((double *)__pyx_v_close->data);
+  __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close));
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(3, 2421, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 1729, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
   __pyx_v_outinteger = 0;
 
-  __pyx_v_retCode = TA_CDLSHORTLINE((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
+  __pyx_v_retCode = TA_CDLHIKKAKEMOD((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLSHORTLINE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2424, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLHIKKAKEMOD, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1732, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2425, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1733, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -50019,7 +60563,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_492stream_CDLSHORTLINE(CYTHON_UNUSED P
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLSHORTLINE", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLHIKKAKEMOD", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_open);
@@ -50033,99 +60577,129 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_492stream_CDLSHORTLINE(CYTHON_UNUSED P
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_495stream_CDLSPINNINGTOP(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_494stream_CDLSPINNINGTOP[] = " CDLSPINNINGTOP(open, high, low, close)\n\n    Spinning Top (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_495stream_CDLSPINNINGTOP = {"stream_CDLSPINNINGTOP", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_495stream_CDLSPINNINGTOP, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_494stream_CDLSPINNINGTOP};
-static PyObject *__pyx_pw_5talib_7_ta_lib_495stream_CDLSPINNINGTOP(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_463stream_CDLHOMINGPIGEON(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_462stream_CDLHOMINGPIGEON, "stream_CDLHOMINGPIGEON(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLHOMINGPIGEON(open, high, low, close)\n\nHoming Pigeon (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_463stream_CDLHOMINGPIGEON = {"stream_CDLHOMINGPIGEON", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_463stream_CDLHOMINGPIGEON, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_462stream_CDLHOMINGPIGEON};
+static PyObject *__pyx_pw_5talib_7_ta_lib_463stream_CDLHOMINGPIGEON(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_open = 0;
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_CDLSPINNINGTOP (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_CDLHOMINGPIGEON (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 1735, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1735, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1735, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1735, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1735, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLSPINNINGTOP", 1, 4, 4, 1); __PYX_ERR(3, 2429, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLSPINNINGTOP", 1, 4, 4, 2); __PYX_ERR(3, 2429, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLSPINNINGTOP", 1, 4, 4, 3); __PYX_ERR(3, 2429, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_CDLSPINNINGTOP") < 0)) __PYX_ERR(3, 2429, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLHOMINGPIGEON", 0) < (0)) __PYX_ERR(5, 1735, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLHOMINGPIGEON", 1, 4, 4, i); __PYX_ERR(5, 1735, __pyx_L3_error) }
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
+    } else if (unlikely(__pyx_nargs != 4)) {
       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[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1735, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1735, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1735, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1735, __pyx_L3_error)
     }
     __pyx_v_open = ((PyArrayObject *)values[0]);
     __pyx_v_high = ((PyArrayObject *)values[1]);
     __pyx_v_low = ((PyArrayObject *)values[2]);
     __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_CDLSPINNINGTOP", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 2429, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_CDLHOMINGPIGEON", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 1735, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLSPINNINGTOP", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLHOMINGPIGEON", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 2429, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 2429, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 2429, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 2429, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_494stream_CDLSPINNINGTOP(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 1737, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 1737, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 1737, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 1737, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_462stream_CDLHOMINGPIGEON(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_494stream_CDLSPINNINGTOP(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_462stream_CDLHOMINGPIGEON(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
   double *__pyx_v_open_data;
@@ -50139,53 +60713,56 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_494stream_CDLSPINNINGTOP(CYTHON_UNUSED
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
-  __Pyx_RefNannySetupContext("stream_CDLSPINNINGTOP", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_CDLHOMINGPIGEON", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_open);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2449, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1757, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_open_data = ((double *)__pyx_v_open->data);
+  __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2451, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1759, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_high_data = ((double *)__pyx_v_high->data);
+  __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2453, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1761, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_low_data = ((double *)__pyx_v_low->data);
+  __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2455, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1763, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_close_data = ((double *)__pyx_v_close->data);
+  __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close));
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(3, 2457, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 1765, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
   __pyx_v_outinteger = 0;
 
-  __pyx_v_retCode = TA_CDLSPINNINGTOP((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
+  __pyx_v_retCode = TA_CDLHOMINGPIGEON((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLSPINNINGTOP, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2460, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLHOMINGPIGEON, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1768, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2461, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1769, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -50195,7 +60772,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_494stream_CDLSPINNINGTOP(CYTHON_UNUSED
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLSPINNINGTOP", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLHOMINGPIGEON", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_open);
@@ -50209,99 +60786,129 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_494stream_CDLSPINNINGTOP(CYTHON_UNUSED
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_497stream_CDLSTALLEDPATTERN(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_496stream_CDLSTALLEDPATTERN[] = " CDLSTALLEDPATTERN(open, high, low, close)\n\n    Stalled Pattern (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_497stream_CDLSTALLEDPATTERN = {"stream_CDLSTALLEDPATTERN", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_497stream_CDLSTALLEDPATTERN, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_496stream_CDLSTALLEDPATTERN};
-static PyObject *__pyx_pw_5talib_7_ta_lib_497stream_CDLSTALLEDPATTERN(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_465stream_CDLIDENTICAL3CROWS(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_464stream_CDLIDENTICAL3CROWS, "stream_CDLIDENTICAL3CROWS(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLIDENTICAL3CROWS(open, high, low, close)\n\nIdentical Three Crows (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_465stream_CDLIDENTICAL3CROWS = {"stream_CDLIDENTICAL3CROWS", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_465stream_CDLIDENTICAL3CROWS, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_464stream_CDLIDENTICAL3CROWS};
+static PyObject *__pyx_pw_5talib_7_ta_lib_465stream_CDLIDENTICAL3CROWS(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_open = 0;
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_CDLSTALLEDPATTERN (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_CDLIDENTICAL3CROWS (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 1771, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1771, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1771, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1771, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1771, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLSTALLEDPATTERN", 1, 4, 4, 1); __PYX_ERR(3, 2465, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLSTALLEDPATTERN", 1, 4, 4, 2); __PYX_ERR(3, 2465, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLSTALLEDPATTERN", 1, 4, 4, 3); __PYX_ERR(3, 2465, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_CDLSTALLEDPATTERN") < 0)) __PYX_ERR(3, 2465, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLIDENTICAL3CROWS", 0) < (0)) __PYX_ERR(5, 1771, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLIDENTICAL3CROWS", 1, 4, 4, i); __PYX_ERR(5, 1771, __pyx_L3_error) }
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
+    } else if (unlikely(__pyx_nargs != 4)) {
       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[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1771, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1771, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1771, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1771, __pyx_L3_error)
     }
     __pyx_v_open = ((PyArrayObject *)values[0]);
     __pyx_v_high = ((PyArrayObject *)values[1]);
     __pyx_v_low = ((PyArrayObject *)values[2]);
     __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_CDLSTALLEDPATTERN", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 2465, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_CDLIDENTICAL3CROWS", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 1771, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLSTALLEDPATTERN", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLIDENTICAL3CROWS", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 2465, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 2465, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 2465, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 2465, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_496stream_CDLSTALLEDPATTERN(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 1773, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 1773, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 1773, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 1773, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_464stream_CDLIDENTICAL3CROWS(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_496stream_CDLSTALLEDPATTERN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_464stream_CDLIDENTICAL3CROWS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
   double *__pyx_v_open_data;
@@ -50315,53 +60922,56 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_496stream_CDLSTALLEDPATTERN(CYTHON_UNU
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
-  __Pyx_RefNannySetupContext("stream_CDLSTALLEDPATTERN", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_CDLIDENTICAL3CROWS", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_open);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2485, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1793, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_open_data = ((double *)__pyx_v_open->data);
+  __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2487, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1795, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_high_data = ((double *)__pyx_v_high->data);
+  __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2489, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1797, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_low_data = ((double *)__pyx_v_low->data);
+  __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2491, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1799, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_close_data = ((double *)__pyx_v_close->data);
+  __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close));
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(3, 2493, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 1801, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
   __pyx_v_outinteger = 0;
 
-  __pyx_v_retCode = TA_CDLSTALLEDPATTERN((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
+  __pyx_v_retCode = TA_CDLIDENTICAL3CROWS((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLSTALLEDPATTERN, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2496, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLIDENTICAL3CROWS, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1804, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2497, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1805, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -50371,7 +60981,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_496stream_CDLSTALLEDPATTERN(CYTHON_UNU
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLSTALLEDPATTERN", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLIDENTICAL3CROWS", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_open);
@@ -50385,99 +60995,129 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_496stream_CDLSTALLEDPATTERN(CYTHON_UNU
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_499stream_CDLSTICKSANDWICH(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_498stream_CDLSTICKSANDWICH[] = " CDLSTICKSANDWICH(open, high, low, close)\n\n    Stick Sandwich (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_499stream_CDLSTICKSANDWICH = {"stream_CDLSTICKSANDWICH", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_499stream_CDLSTICKSANDWICH, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_498stream_CDLSTICKSANDWICH};
-static PyObject *__pyx_pw_5talib_7_ta_lib_499stream_CDLSTICKSANDWICH(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_467stream_CDLINNECK(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_466stream_CDLINNECK, "stream_CDLINNECK(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLINNECK(open, high, low, close)\n\nIn-Neck Pattern (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_467stream_CDLINNECK = {"stream_CDLINNECK", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_467stream_CDLINNECK, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_466stream_CDLINNECK};
+static PyObject *__pyx_pw_5talib_7_ta_lib_467stream_CDLINNECK(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_open = 0;
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_CDLSTICKSANDWICH (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_CDLINNECK (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 1807, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1807, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1807, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1807, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1807, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLSTICKSANDWICH", 1, 4, 4, 1); __PYX_ERR(3, 2501, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLSTICKSANDWICH", 1, 4, 4, 2); __PYX_ERR(3, 2501, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLSTICKSANDWICH", 1, 4, 4, 3); __PYX_ERR(3, 2501, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_CDLSTICKSANDWICH") < 0)) __PYX_ERR(3, 2501, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLINNECK", 0) < (0)) __PYX_ERR(5, 1807, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLINNECK", 1, 4, 4, i); __PYX_ERR(5, 1807, __pyx_L3_error) }
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
+    } else if (unlikely(__pyx_nargs != 4)) {
       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[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1807, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1807, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1807, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1807, __pyx_L3_error)
     }
     __pyx_v_open = ((PyArrayObject *)values[0]);
     __pyx_v_high = ((PyArrayObject *)values[1]);
     __pyx_v_low = ((PyArrayObject *)values[2]);
     __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_CDLSTICKSANDWICH", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 2501, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_CDLINNECK", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 1807, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLSTICKSANDWICH", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLINNECK", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 2501, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 2501, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 2501, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 2501, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_498stream_CDLSTICKSANDWICH(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 1809, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 1809, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 1809, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 1809, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_466stream_CDLINNECK(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_498stream_CDLSTICKSANDWICH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_466stream_CDLINNECK(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
   double *__pyx_v_open_data;
@@ -50491,53 +61131,56 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_498stream_CDLSTICKSANDWICH(CYTHON_UNUS
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
-  __Pyx_RefNannySetupContext("stream_CDLSTICKSANDWICH", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_CDLINNECK", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_open);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2521, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1829, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_open_data = ((double *)__pyx_v_open->data);
+  __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2523, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1831, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_high_data = ((double *)__pyx_v_high->data);
+  __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2525, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1833, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_low_data = ((double *)__pyx_v_low->data);
+  __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2527, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1835, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_close_data = ((double *)__pyx_v_close->data);
+  __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close));
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(3, 2529, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 1837, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
   __pyx_v_outinteger = 0;
 
-  __pyx_v_retCode = TA_CDLSTICKSANDWICH((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
+  __pyx_v_retCode = TA_CDLINNECK((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLSTICKSANDWICH, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2532, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLINNECK, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1840, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2533, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1841, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -50547,7 +61190,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_498stream_CDLSTICKSANDWICH(CYTHON_UNUS
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLSTICKSANDWICH", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLINNECK", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_open);
@@ -50561,99 +61204,129 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_498stream_CDLSTICKSANDWICH(CYTHON_UNUS
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_501stream_CDLTAKURI(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_500stream_CDLTAKURI[] = " CDLTAKURI(open, high, low, close)\n\n    Takuri (Dragonfly Doji with very long lower shadow) (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_501stream_CDLTAKURI = {"stream_CDLTAKURI", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_501stream_CDLTAKURI, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_500stream_CDLTAKURI};
-static PyObject *__pyx_pw_5talib_7_ta_lib_501stream_CDLTAKURI(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_469stream_CDLINVERTEDHAMMER(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_468stream_CDLINVERTEDHAMMER, "stream_CDLINVERTEDHAMMER(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLINVERTEDHAMMER(open, high, low, close)\n\nInverted Hammer (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_469stream_CDLINVERTEDHAMMER = {"stream_CDLINVERTEDHAMMER", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_469stream_CDLINVERTEDHAMMER, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_468stream_CDLINVERTEDHAMMER};
+static PyObject *__pyx_pw_5talib_7_ta_lib_469stream_CDLINVERTEDHAMMER(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_open = 0;
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_CDLTAKURI (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_CDLINVERTEDHAMMER (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 1843, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1843, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1843, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1843, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1843, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLTAKURI", 1, 4, 4, 1); __PYX_ERR(3, 2537, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLTAKURI", 1, 4, 4, 2); __PYX_ERR(3, 2537, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLTAKURI", 1, 4, 4, 3); __PYX_ERR(3, 2537, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_CDLTAKURI") < 0)) __PYX_ERR(3, 2537, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLINVERTEDHAMMER", 0) < (0)) __PYX_ERR(5, 1843, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLINVERTEDHAMMER", 1, 4, 4, i); __PYX_ERR(5, 1843, __pyx_L3_error) }
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
+    } else if (unlikely(__pyx_nargs != 4)) {
       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[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1843, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1843, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1843, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1843, __pyx_L3_error)
     }
     __pyx_v_open = ((PyArrayObject *)values[0]);
     __pyx_v_high = ((PyArrayObject *)values[1]);
     __pyx_v_low = ((PyArrayObject *)values[2]);
     __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_CDLTAKURI", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 2537, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_CDLINVERTEDHAMMER", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 1843, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLTAKURI", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLINVERTEDHAMMER", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 2537, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 2537, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 2537, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 2537, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_500stream_CDLTAKURI(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 1845, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 1845, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 1845, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 1845, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_468stream_CDLINVERTEDHAMMER(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_500stream_CDLTAKURI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_468stream_CDLINVERTEDHAMMER(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
   double *__pyx_v_open_data;
@@ -50667,53 +61340,56 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_500stream_CDLTAKURI(CYTHON_UNUSED PyOb
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
-  __Pyx_RefNannySetupContext("stream_CDLTAKURI", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_CDLINVERTEDHAMMER", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_open);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2557, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1865, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_open_data = ((double *)__pyx_v_open->data);
+  __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2559, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1867, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_high_data = ((double *)__pyx_v_high->data);
+  __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2561, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1869, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_low_data = ((double *)__pyx_v_low->data);
+  __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2563, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1871, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_close_data = ((double *)__pyx_v_close->data);
+  __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close));
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(3, 2565, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 1873, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
   __pyx_v_outinteger = 0;
 
-  __pyx_v_retCode = TA_CDLTAKURI((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
+  __pyx_v_retCode = TA_CDLINVERTEDHAMMER((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLTAKURI, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2568, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLINVERTEDHAMMER, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1876, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2569, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1877, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -50723,7 +61399,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_500stream_CDLTAKURI(CYTHON_UNUSED PyOb
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLTAKURI", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLINVERTEDHAMMER", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_open);
@@ -50737,99 +61413,129 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_500stream_CDLTAKURI(CYTHON_UNUSED PyOb
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_503stream_CDLTASUKIGAP(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_502stream_CDLTASUKIGAP[] = " CDLTASUKIGAP(open, high, low, close)\n\n    Tasuki Gap (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_503stream_CDLTASUKIGAP = {"stream_CDLTASUKIGAP", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_503stream_CDLTASUKIGAP, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_502stream_CDLTASUKIGAP};
-static PyObject *__pyx_pw_5talib_7_ta_lib_503stream_CDLTASUKIGAP(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_471stream_CDLKICKING(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_470stream_CDLKICKING, "stream_CDLKICKING(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLKICKING(open, high, low, close)\n\nKicking (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_471stream_CDLKICKING = {"stream_CDLKICKING", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_471stream_CDLKICKING, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_470stream_CDLKICKING};
+static PyObject *__pyx_pw_5talib_7_ta_lib_471stream_CDLKICKING(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_open = 0;
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_CDLTASUKIGAP (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_CDLKICKING (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 1879, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1879, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1879, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1879, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1879, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLTASUKIGAP", 1, 4, 4, 1); __PYX_ERR(3, 2573, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLTASUKIGAP", 1, 4, 4, 2); __PYX_ERR(3, 2573, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLTASUKIGAP", 1, 4, 4, 3); __PYX_ERR(3, 2573, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_CDLTASUKIGAP") < 0)) __PYX_ERR(3, 2573, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLKICKING", 0) < (0)) __PYX_ERR(5, 1879, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLKICKING", 1, 4, 4, i); __PYX_ERR(5, 1879, __pyx_L3_error) }
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
+    } else if (unlikely(__pyx_nargs != 4)) {
       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[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1879, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1879, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1879, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1879, __pyx_L3_error)
     }
     __pyx_v_open = ((PyArrayObject *)values[0]);
     __pyx_v_high = ((PyArrayObject *)values[1]);
     __pyx_v_low = ((PyArrayObject *)values[2]);
     __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_CDLTASUKIGAP", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 2573, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_CDLKICKING", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 1879, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLTASUKIGAP", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLKICKING", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 2573, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 2573, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 2573, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 2573, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_502stream_CDLTASUKIGAP(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 1881, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 1881, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 1881, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 1881, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_470stream_CDLKICKING(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_502stream_CDLTASUKIGAP(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_470stream_CDLKICKING(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
   double *__pyx_v_open_data;
@@ -50843,53 +61549,56 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_502stream_CDLTASUKIGAP(CYTHON_UNUSED P
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
-  __Pyx_RefNannySetupContext("stream_CDLTASUKIGAP", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_CDLKICKING", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_open);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2593, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1901, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_open_data = ((double *)__pyx_v_open->data);
+  __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2595, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1903, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_high_data = ((double *)__pyx_v_high->data);
+  __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2597, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1905, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_low_data = ((double *)__pyx_v_low->data);
+  __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2599, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1907, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_close_data = ((double *)__pyx_v_close->data);
+  __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close));
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(3, 2601, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 1909, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
   __pyx_v_outinteger = 0;
 
-  __pyx_v_retCode = TA_CDLTASUKIGAP((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
+  __pyx_v_retCode = TA_CDLKICKING((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLTASUKIGAP, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2604, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLKICKING, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1912, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2605, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1913, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -50899,7 +61608,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_502stream_CDLTASUKIGAP(CYTHON_UNUSED P
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLTASUKIGAP", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLKICKING", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_open);
@@ -50913,99 +61622,129 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_502stream_CDLTASUKIGAP(CYTHON_UNUSED P
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_505stream_CDLTHRUSTING(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_504stream_CDLTHRUSTING[] = " CDLTHRUSTING(open, high, low, close)\n\n    Thrusting Pattern (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_505stream_CDLTHRUSTING = {"stream_CDLTHRUSTING", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_505stream_CDLTHRUSTING, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_504stream_CDLTHRUSTING};
-static PyObject *__pyx_pw_5talib_7_ta_lib_505stream_CDLTHRUSTING(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_473stream_CDLKICKINGBYLENGTH(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_472stream_CDLKICKINGBYLENGTH, "stream_CDLKICKINGBYLENGTH(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLKICKINGBYLENGTH(open, high, low, close)\n\nKicking - bull/bear determined by the longer marubozu (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_473stream_CDLKICKINGBYLENGTH = {"stream_CDLKICKINGBYLENGTH", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_473stream_CDLKICKINGBYLENGTH, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_472stream_CDLKICKINGBYLENGTH};
+static PyObject *__pyx_pw_5talib_7_ta_lib_473stream_CDLKICKINGBYLENGTH(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_open = 0;
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_CDLTHRUSTING (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_CDLKICKINGBYLENGTH (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 1915, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1915, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1915, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1915, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1915, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLTHRUSTING", 1, 4, 4, 1); __PYX_ERR(3, 2609, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLTHRUSTING", 1, 4, 4, 2); __PYX_ERR(3, 2609, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLTHRUSTING", 1, 4, 4, 3); __PYX_ERR(3, 2609, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_CDLTHRUSTING") < 0)) __PYX_ERR(3, 2609, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLKICKINGBYLENGTH", 0) < (0)) __PYX_ERR(5, 1915, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLKICKINGBYLENGTH", 1, 4, 4, i); __PYX_ERR(5, 1915, __pyx_L3_error) }
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
+    } else if (unlikely(__pyx_nargs != 4)) {
       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[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1915, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1915, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1915, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1915, __pyx_L3_error)
     }
     __pyx_v_open = ((PyArrayObject *)values[0]);
     __pyx_v_high = ((PyArrayObject *)values[1]);
     __pyx_v_low = ((PyArrayObject *)values[2]);
     __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_CDLTHRUSTING", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 2609, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_CDLKICKINGBYLENGTH", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 1915, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLTHRUSTING", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLKICKINGBYLENGTH", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 2609, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 2609, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 2609, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 2609, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_504stream_CDLTHRUSTING(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 1917, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 1917, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 1917, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 1917, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_472stream_CDLKICKINGBYLENGTH(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_504stream_CDLTHRUSTING(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_472stream_CDLKICKINGBYLENGTH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
   double *__pyx_v_open_data;
@@ -51019,53 +61758,56 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_504stream_CDLTHRUSTING(CYTHON_UNUSED P
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
-  __Pyx_RefNannySetupContext("stream_CDLTHRUSTING", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_CDLKICKINGBYLENGTH", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_open);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2629, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1937, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_open_data = ((double *)__pyx_v_open->data);
+  __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2631, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1939, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_high_data = ((double *)__pyx_v_high->data);
+  __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2633, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1941, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_low_data = ((double *)__pyx_v_low->data);
+  __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2635, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1943, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_close_data = ((double *)__pyx_v_close->data);
+  __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close));
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(3, 2637, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 1945, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
   __pyx_v_outinteger = 0;
 
-  __pyx_v_retCode = TA_CDLTHRUSTING((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
+  __pyx_v_retCode = TA_CDLKICKINGBYLENGTH((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLTHRUSTING, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2640, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLKICKINGBYLENGTH, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1948, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2641, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1949, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -51075,7 +61817,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_504stream_CDLTHRUSTING(CYTHON_UNUSED P
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLTHRUSTING", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLKICKINGBYLENGTH", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_open);
@@ -51089,99 +61831,129 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_504stream_CDLTHRUSTING(CYTHON_UNUSED P
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_507stream_CDLTRISTAR(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_506stream_CDLTRISTAR[] = " CDLTRISTAR(open, high, low, close)\n\n    Tristar Pattern (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_507stream_CDLTRISTAR = {"stream_CDLTRISTAR", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_507stream_CDLTRISTAR, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_506stream_CDLTRISTAR};
-static PyObject *__pyx_pw_5talib_7_ta_lib_507stream_CDLTRISTAR(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_475stream_CDLLADDERBOTTOM(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_474stream_CDLLADDERBOTTOM, "stream_CDLLADDERBOTTOM(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLLADDERBOTTOM(open, high, low, close)\n\nLadder Bottom (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_475stream_CDLLADDERBOTTOM = {"stream_CDLLADDERBOTTOM", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_475stream_CDLLADDERBOTTOM, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_474stream_CDLLADDERBOTTOM};
+static PyObject *__pyx_pw_5talib_7_ta_lib_475stream_CDLLADDERBOTTOM(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_open = 0;
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_CDLTRISTAR (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_CDLLADDERBOTTOM (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 1951, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1951, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1951, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1951, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1951, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLTRISTAR", 1, 4, 4, 1); __PYX_ERR(3, 2645, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLTRISTAR", 1, 4, 4, 2); __PYX_ERR(3, 2645, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLTRISTAR", 1, 4, 4, 3); __PYX_ERR(3, 2645, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_CDLTRISTAR") < 0)) __PYX_ERR(3, 2645, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLLADDERBOTTOM", 0) < (0)) __PYX_ERR(5, 1951, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLLADDERBOTTOM", 1, 4, 4, i); __PYX_ERR(5, 1951, __pyx_L3_error) }
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
+    } else if (unlikely(__pyx_nargs != 4)) {
       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[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1951, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1951, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1951, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1951, __pyx_L3_error)
     }
     __pyx_v_open = ((PyArrayObject *)values[0]);
     __pyx_v_high = ((PyArrayObject *)values[1]);
     __pyx_v_low = ((PyArrayObject *)values[2]);
     __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_CDLTRISTAR", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 2645, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_CDLLADDERBOTTOM", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 1951, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLTRISTAR", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLLADDERBOTTOM", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 2645, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 2645, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 2645, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 2645, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_506stream_CDLTRISTAR(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 1953, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 1953, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 1953, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 1953, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_474stream_CDLLADDERBOTTOM(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_506stream_CDLTRISTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_474stream_CDLLADDERBOTTOM(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
   double *__pyx_v_open_data;
@@ -51195,53 +61967,56 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_506stream_CDLTRISTAR(CYTHON_UNUSED PyO
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
-  __Pyx_RefNannySetupContext("stream_CDLTRISTAR", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_CDLLADDERBOTTOM", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_open);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2665, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1973, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_open_data = ((double *)__pyx_v_open->data);
+  __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2667, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1975, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_high_data = ((double *)__pyx_v_high->data);
+  __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2669, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1977, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_low_data = ((double *)__pyx_v_low->data);
+  __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2671, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1979, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_close_data = ((double *)__pyx_v_close->data);
+  __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close));
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(3, 2673, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 1981, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
   __pyx_v_outinteger = 0;
 
-  __pyx_v_retCode = TA_CDLTRISTAR((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
+  __pyx_v_retCode = TA_CDLLADDERBOTTOM((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLTRISTAR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2676, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLLADDERBOTTOM, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1984, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2677, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1985, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -51251,7 +62026,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_506stream_CDLTRISTAR(CYTHON_UNUSED PyO
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLTRISTAR", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLLADDERBOTTOM", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_open);
@@ -51265,99 +62040,129 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_506stream_CDLTRISTAR(CYTHON_UNUSED PyO
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_509stream_CDLUNIQUE3RIVER(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_508stream_CDLUNIQUE3RIVER[] = " CDLUNIQUE3RIVER(open, high, low, close)\n\n    Unique 3 River (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_509stream_CDLUNIQUE3RIVER = {"stream_CDLUNIQUE3RIVER", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_509stream_CDLUNIQUE3RIVER, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_508stream_CDLUNIQUE3RIVER};
-static PyObject *__pyx_pw_5talib_7_ta_lib_509stream_CDLUNIQUE3RIVER(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_477stream_CDLLONGLEGGEDDOJI(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_476stream_CDLLONGLEGGEDDOJI, "stream_CDLLONGLEGGEDDOJI(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLLONGLEGGEDDOJI(open, high, low, close)\n\nLong Legged Doji (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_477stream_CDLLONGLEGGEDDOJI = {"stream_CDLLONGLEGGEDDOJI", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_477stream_CDLLONGLEGGEDDOJI, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_476stream_CDLLONGLEGGEDDOJI};
+static PyObject *__pyx_pw_5talib_7_ta_lib_477stream_CDLLONGLEGGEDDOJI(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_open = 0;
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_CDLUNIQUE3RIVER (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_CDLLONGLEGGEDDOJI (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 1987, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1987, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1987, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1987, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1987, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLUNIQUE3RIVER", 1, 4, 4, 1); __PYX_ERR(3, 2681, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLUNIQUE3RIVER", 1, 4, 4, 2); __PYX_ERR(3, 2681, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLUNIQUE3RIVER", 1, 4, 4, 3); __PYX_ERR(3, 2681, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_CDLUNIQUE3RIVER") < 0)) __PYX_ERR(3, 2681, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLLONGLEGGEDDOJI", 0) < (0)) __PYX_ERR(5, 1987, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLLONGLEGGEDDOJI", 1, 4, 4, i); __PYX_ERR(5, 1987, __pyx_L3_error) }
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
+    } else if (unlikely(__pyx_nargs != 4)) {
       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[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 1987, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 1987, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 1987, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 1987, __pyx_L3_error)
     }
     __pyx_v_open = ((PyArrayObject *)values[0]);
     __pyx_v_high = ((PyArrayObject *)values[1]);
     __pyx_v_low = ((PyArrayObject *)values[2]);
     __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_CDLUNIQUE3RIVER", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 2681, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_CDLLONGLEGGEDDOJI", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 1987, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLUNIQUE3RIVER", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLLONGLEGGEDDOJI", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 2681, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 2681, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 2681, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 2681, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_508stream_CDLUNIQUE3RIVER(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 1989, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 1989, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 1989, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 1989, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_476stream_CDLLONGLEGGEDDOJI(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_508stream_CDLUNIQUE3RIVER(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_476stream_CDLLONGLEGGEDDOJI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
   double *__pyx_v_open_data;
@@ -51371,53 +62176,56 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_508stream_CDLUNIQUE3RIVER(CYTHON_UNUSE
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
-  __Pyx_RefNannySetupContext("stream_CDLUNIQUE3RIVER", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_CDLLONGLEGGEDDOJI", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_open);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2701, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2009, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_open_data = ((double *)__pyx_v_open->data);
+  __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2703, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2011, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_high_data = ((double *)__pyx_v_high->data);
+  __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2705, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2013, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_low_data = ((double *)__pyx_v_low->data);
+  __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2707, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2015, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_close_data = ((double *)__pyx_v_close->data);
+  __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close));
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(3, 2709, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 2017, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
   __pyx_v_outinteger = 0;
 
-  __pyx_v_retCode = TA_CDLUNIQUE3RIVER((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
+  __pyx_v_retCode = TA_CDLLONGLEGGEDDOJI((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLUNIQUE3RIVER, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2712, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLLONGLEGGEDDOJI, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2020, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2713, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2021, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -51427,7 +62235,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_508stream_CDLUNIQUE3RIVER(CYTHON_UNUSE
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLUNIQUE3RIVER", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLLONGLEGGEDDOJI", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_open);
@@ -51441,99 +62249,129 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_508stream_CDLUNIQUE3RIVER(CYTHON_UNUSE
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_511stream_CDLUPSIDEGAP2CROWS(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_510stream_CDLUPSIDEGAP2CROWS[] = " CDLUPSIDEGAP2CROWS(open, high, low, close)\n\n    Upside Gap Two Crows (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_511stream_CDLUPSIDEGAP2CROWS = {"stream_CDLUPSIDEGAP2CROWS", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_511stream_CDLUPSIDEGAP2CROWS, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_510stream_CDLUPSIDEGAP2CROWS};
-static PyObject *__pyx_pw_5talib_7_ta_lib_511stream_CDLUPSIDEGAP2CROWS(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_479stream_CDLLONGLINE(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_478stream_CDLLONGLINE, "stream_CDLLONGLINE(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLLONGLINE(open, high, low, close)\n\nLong Line Candle (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_479stream_CDLLONGLINE = {"stream_CDLLONGLINE", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_479stream_CDLLONGLINE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_478stream_CDLLONGLINE};
+static PyObject *__pyx_pw_5talib_7_ta_lib_479stream_CDLLONGLINE(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_open = 0;
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_CDLUPSIDEGAP2CROWS (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_CDLLONGLINE (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 2023, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 2023, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 2023, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 2023, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2023, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLUPSIDEGAP2CROWS", 1, 4, 4, 1); __PYX_ERR(3, 2717, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLUPSIDEGAP2CROWS", 1, 4, 4, 2); __PYX_ERR(3, 2717, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLUPSIDEGAP2CROWS", 1, 4, 4, 3); __PYX_ERR(3, 2717, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_CDLUPSIDEGAP2CROWS") < 0)) __PYX_ERR(3, 2717, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLLONGLINE", 0) < (0)) __PYX_ERR(5, 2023, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLLONGLINE", 1, 4, 4, i); __PYX_ERR(5, 2023, __pyx_L3_error) }
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
+    } else if (unlikely(__pyx_nargs != 4)) {
       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[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2023, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 2023, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 2023, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 2023, __pyx_L3_error)
     }
     __pyx_v_open = ((PyArrayObject *)values[0]);
     __pyx_v_high = ((PyArrayObject *)values[1]);
     __pyx_v_low = ((PyArrayObject *)values[2]);
     __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_CDLUPSIDEGAP2CROWS", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 2717, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_CDLLONGLINE", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 2023, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLUPSIDEGAP2CROWS", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLLONGLINE", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 2717, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 2717, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 2717, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 2717, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_510stream_CDLUPSIDEGAP2CROWS(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 2025, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 2025, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 2025, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 2025, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_478stream_CDLLONGLINE(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_510stream_CDLUPSIDEGAP2CROWS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_478stream_CDLLONGLINE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
   double *__pyx_v_open_data;
@@ -51547,53 +62385,56 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_510stream_CDLUPSIDEGAP2CROWS(CYTHON_UN
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
-  __Pyx_RefNannySetupContext("stream_CDLUPSIDEGAP2CROWS", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_CDLLONGLINE", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_open);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2737, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2045, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_open_data = ((double *)__pyx_v_open->data);
+  __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2739, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2047, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_high_data = ((double *)__pyx_v_high->data);
+  __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2741, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2049, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_low_data = ((double *)__pyx_v_low->data);
+  __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2743, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2051, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_close_data = ((double *)__pyx_v_close->data);
+  __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close));
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(3, 2745, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 2053, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
   __pyx_v_outinteger = 0;
 
-  __pyx_v_retCode = TA_CDLUPSIDEGAP2CROWS((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
+  __pyx_v_retCode = TA_CDLLONGLINE((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLUPSIDEGAP2CROWS, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2748, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLLONGLINE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2056, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2749, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2057, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -51603,7 +62444,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_510stream_CDLUPSIDEGAP2CROWS(CYTHON_UN
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLUPSIDEGAP2CROWS", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLLONGLINE", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_open);
@@ -51617,99 +62458,129 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_510stream_CDLUPSIDEGAP2CROWS(CYTHON_UN
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_513stream_CDLXSIDEGAP3METHODS(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_512stream_CDLXSIDEGAP3METHODS[] = " CDLXSIDEGAP3METHODS(open, high, low, close)\n\n    Upside/Downside Gap Three Methods (Pattern Recognition)\n\n    Inputs:\n        prices: ['open', 'high', 'low', 'close']\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_513stream_CDLXSIDEGAP3METHODS = {"stream_CDLXSIDEGAP3METHODS", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_513stream_CDLXSIDEGAP3METHODS, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_512stream_CDLXSIDEGAP3METHODS};
-static PyObject *__pyx_pw_5talib_7_ta_lib_513stream_CDLXSIDEGAP3METHODS(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_481stream_CDLMARUBOZU(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_480stream_CDLMARUBOZU, "stream_CDLMARUBOZU(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLMARUBOZU(open, high, low, close)\n\nMarubozu (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_481stream_CDLMARUBOZU = {"stream_CDLMARUBOZU", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_481stream_CDLMARUBOZU, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_480stream_CDLMARUBOZU};
+static PyObject *__pyx_pw_5talib_7_ta_lib_481stream_CDLMARUBOZU(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_open = 0;
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_CDLXSIDEGAP3METHODS (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_CDLMARUBOZU (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_open,&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 2059, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 2059, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 2059, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 2059, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2059, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_open)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLXSIDEGAP3METHODS", 1, 4, 4, 1); __PYX_ERR(3, 2753, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLXSIDEGAP3METHODS", 1, 4, 4, 2); __PYX_ERR(3, 2753, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CDLXSIDEGAP3METHODS", 1, 4, 4, 3); __PYX_ERR(3, 2753, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_CDLXSIDEGAP3METHODS") < 0)) __PYX_ERR(3, 2753, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLMARUBOZU", 0) < (0)) __PYX_ERR(5, 2059, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLMARUBOZU", 1, 4, 4, i); __PYX_ERR(5, 2059, __pyx_L3_error) }
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
+    } else if (unlikely(__pyx_nargs != 4)) {
       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[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2059, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 2059, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 2059, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 2059, __pyx_L3_error)
     }
     __pyx_v_open = ((PyArrayObject *)values[0]);
     __pyx_v_high = ((PyArrayObject *)values[1]);
     __pyx_v_low = ((PyArrayObject *)values[2]);
     __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_CDLXSIDEGAP3METHODS", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 2753, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_CDLMARUBOZU", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 2059, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLXSIDEGAP3METHODS", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLMARUBOZU", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(3, 2753, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 2753, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 2753, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 2753, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_512stream_CDLXSIDEGAP3METHODS(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 2061, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 2061, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 2061, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 2061, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_480stream_CDLMARUBOZU(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_512stream_CDLXSIDEGAP3METHODS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_480stream_CDLMARUBOZU(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
   double *__pyx_v_open_data;
@@ -51723,53 +62594,56 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_512stream_CDLXSIDEGAP3METHODS(CYTHON_U
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
-  __Pyx_RefNannySetupContext("stream_CDLXSIDEGAP3METHODS", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_CDLMARUBOZU", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_open);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2773, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2081, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_open_data = ((double *)__pyx_v_open->data);
+  __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2775, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2083, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_high_data = ((double *)__pyx_v_high->data);
+  __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2777, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2085, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_low_data = ((double *)__pyx_v_low->data);
+  __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2779, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2087, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_close_data = ((double *)__pyx_v_close->data);
+  __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close));
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(3, 2781, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 2089, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
   __pyx_v_outinteger = 0;
 
-  __pyx_v_retCode = TA_CDLXSIDEGAP3METHODS((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
+  __pyx_v_retCode = TA_CDLMARUBOZU((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CDLXSIDEGAP3METHODS, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2784, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLMARUBOZU, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2092, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2785, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2093, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -51779,7 +62653,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_512stream_CDLXSIDEGAP3METHODS(CYTHON_U
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_CDLXSIDEGAP3METHODS", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLMARUBOZU", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_open);
@@ -51793,57 +62667,192 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_512stream_CDLXSIDEGAP3METHODS(CYTHON_U
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_515stream_CEIL(PyObject *__pyx_self, PyObject *__pyx_v_real); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_514stream_CEIL[] = " CEIL(real)\n\n    Vector Ceil (Math Transform)\n\n    Inputs:\n        real: (any ndarray)\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_515stream_CEIL = {"stream_CEIL", (PyCFunction)__pyx_pw_5talib_7_ta_lib_515stream_CEIL, METH_O, __pyx_doc_5talib_7_ta_lib_514stream_CEIL};
-static PyObject *__pyx_pw_5talib_7_ta_lib_515stream_CEIL(PyObject *__pyx_self, PyObject *__pyx_v_real) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_483stream_CDLMATCHINGLOW(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_482stream_CDLMATCHINGLOW, "stream_CDLMATCHINGLOW(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLMATCHINGLOW(open, high, low, close)\n\nMatching Low (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_483stream_CDLMATCHINGLOW = {"stream_CDLMATCHINGLOW", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_483stream_CDLMATCHINGLOW, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_482stream_CDLMATCHINGLOW};
+static PyObject *__pyx_pw_5talib_7_ta_lib_483stream_CDLMATCHINGLOW(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_open = 0;
+  PyArrayObject *__pyx_v_high = 0;
+  PyArrayObject *__pyx_v_low = 0;
+  PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_CEIL (wrapper)", 0);
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 2789, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_514stream_CEIL(__pyx_self, ((PyArrayObject *)__pyx_v_real));
+  __Pyx_RefNannySetupContext("stream_CDLMATCHINGLOW (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 2095, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 2095, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 2095, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 2095, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2095, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLMATCHINGLOW", 0) < (0)) __PYX_ERR(5, 2095, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLMATCHINGLOW", 1, 4, 4, i); __PYX_ERR(5, 2095, __pyx_L3_error) }
+      }
+    } else if (unlikely(__pyx_nargs != 4)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2095, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 2095, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 2095, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 2095, __pyx_L3_error)
+    }
+    __pyx_v_open = ((PyArrayObject *)values[0]);
+    __pyx_v_high = ((PyArrayObject *)values[1]);
+    __pyx_v_low = ((PyArrayObject *)values[2]);
+    __pyx_v_close = ((PyArrayObject *)values[3]);
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("stream_CDLMATCHINGLOW", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 2095, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLMATCHINGLOW", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 2097, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 2097, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 2097, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 2097, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_482stream_CDLMATCHINGLOW(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_514stream_CEIL(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_482stream_CDLMATCHINGLOW(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
-  double *__pyx_v_real_data;
+  double *__pyx_v_open_data;
+  double *__pyx_v_high_data;
+  double *__pyx_v_low_data;
+  double *__pyx_v_close_data;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  double __pyx_v_outreal;
+  int __pyx_v_outinteger;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  __Pyx_RefNannySetupContext("stream_CEIL", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_real);
+  npy_intp __pyx_t_2;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_CDLMATCHINGLOW", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_open);
+  __Pyx_INCREF((PyObject *)__pyx_v_high);
+  __Pyx_INCREF((PyObject *)__pyx_v_low);
+  __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2806, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2117, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_real_data = ((double *)__pyx_v_real->data);
+  __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open));
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2119, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
 
-  __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
+  __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high));
 
-  __pyx_v_retCode = TA_CEIL((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2121, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
+
+  __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low));
+
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2123, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
+
+  __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close));
+
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 2125, __pyx_L1_error)
+  __pyx_v_length = __pyx_t_2;
+
+  __pyx_v_outinteger = 0;
+
+  __pyx_v_retCode = TA_CDLMATCHINGLOW((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CEIL, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2811, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLMATCHINGLOW, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2128, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2812, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2129, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -51853,10 +62862,13 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_514stream_CEIL(CYTHON_UNUSED PyObject
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_CEIL", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLMATCHINGLOW", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_real);
+  __Pyx_XDECREF((PyObject *)__pyx_v_open);
+  __Pyx_XDECREF((PyObject *)__pyx_v_high);
+  __Pyx_XDECREF((PyObject *)__pyx_v_low);
+  __Pyx_XDECREF((PyObject *)__pyx_v_close);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -51864,112 +62876,209 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_514stream_CEIL(CYTHON_UNUSED PyObject
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_517stream_CMO(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_516stream_CMO[] = " CMO(real[, timeperiod=?])\n\n    Chande Momentum Oscillator (Momentum Indicators)\n\n    Inputs:\n        real: (any ndarray)\n    Parameters:\n        timeperiod: 14\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_517stream_CMO = {"stream_CMO", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_517stream_CMO, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_516stream_CMO};
-static PyObject *__pyx_pw_5talib_7_ta_lib_517stream_CMO(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_real = 0;
-  int __pyx_v_timeperiod;
+static PyObject *__pyx_pw_5talib_7_ta_lib_485stream_CDLMATHOLD(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_484stream_CDLMATHOLD, "stream_CDLMATHOLD(ndarray open, ndarray high, ndarray low, ndarray close, double penetration=0.5)\n\nCDLMATHOLD(open, high, low, close[, penetration=?])\n\nMat Hold (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nParameters:\n    penetration: 0.5\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_485stream_CDLMATHOLD = {"stream_CDLMATHOLD", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_485stream_CDLMATHOLD, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_484stream_CDLMATHOLD};
+static PyObject *__pyx_pw_5talib_7_ta_lib_485stream_CDLMATHOLD(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_open = 0;
+  PyArrayObject *__pyx_v_high = 0;
+  PyArrayObject *__pyx_v_low = 0;
+  PyArrayObject *__pyx_v_close = 0;
+  double __pyx_v_penetration;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[5] = {0,0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_CMO (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_CDLMATHOLD (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,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);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,&__pyx_mstate_global->__pyx_n_u_penetration,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 2131, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  5:
+        values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(5, 2131, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 2131, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  0: break;
-        default: goto __pyx_L5_argtuple_error;
-      }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 2131, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 2131, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  1:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod);
-          if (value) { values[1] = value; kw_args--; }
-        }
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2131, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
       }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_CMO") < 0)) __PYX_ERR(3, 2816, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLMATHOLD", 0) < (0)) __PYX_ERR(5, 2131, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLMATHOLD", 0, 4, 5, i); __PYX_ERR(5, 2131, __pyx_L3_error) }
       }
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      switch (__pyx_nargs) {
+        case  5:
+        values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(5, 2131, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 2131, __pyx_L3_error)
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 2131, __pyx_L3_error)
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 2131, __pyx_L3_error)
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2131, __pyx_L3_error)
         break;
         default: goto __pyx_L5_argtuple_error;
       }
     }
-    __pyx_v_real = ((PyArrayObject *)values[0]);
-    if (values[1]) {
-      __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 2816, __pyx_L3_error)
+    __pyx_v_open = ((PyArrayObject *)values[0]);
+    __pyx_v_high = ((PyArrayObject *)values[1]);
+    __pyx_v_low = ((PyArrayObject *)values[2]);
+    __pyx_v_close = ((PyArrayObject *)values[3]);
+    if (values[4]) {
+      __pyx_v_penetration = __Pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_penetration == (double)-1) && PyErr_Occurred())) __PYX_ERR(5, 2133, __pyx_L3_error)
     } else {
-      __pyx_v_timeperiod = ((int)-2147483648);
+      __pyx_v_penetration = ((double)((double)0.5));
     }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_CMO", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 2816, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_CDLMATHOLD", 0, 4, 5, __pyx_nargs); __PYX_ERR(5, 2131, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_CMO", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLMATHOLD", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 2816, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_516stream_CMO(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 2133, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 2133, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 2133, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 2133, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_484stream_CDLMATHOLD(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_penetration);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_516stream_CMO(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_484stream_CDLMATHOLD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
-  double *__pyx_v_real_data;
+  double *__pyx_v_open_data;
+  double *__pyx_v_high_data;
+  double *__pyx_v_low_data;
+  double *__pyx_v_close_data;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  double __pyx_v_outreal;
+  int __pyx_v_outinteger;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  __Pyx_RefNannySetupContext("stream_CMO", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_real);
+  npy_intp __pyx_t_2;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_CDLMATHOLD", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_open);
+  __Pyx_INCREF((PyObject *)__pyx_v_high);
+  __Pyx_INCREF((PyObject *)__pyx_v_low);
+  __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2835, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2155, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_real_data = ((double *)__pyx_v_real->data);
+  __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open));
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2157, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
 
-  __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
+  __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high));
 
-  __pyx_v_retCode = TA_CMO((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2159, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
+
+  __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low));
+
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2161, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
+
+  __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CMO, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2840, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 2163, __pyx_L1_error)
+  __pyx_v_length = __pyx_t_2;
+
+  __pyx_v_outinteger = 0;
+
+  __pyx_v_retCode = TA_CDLMATHOLD((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, __pyx_v_penetration, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
+
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLMATHOLD, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2166, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2841, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2167, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -51979,10 +63088,13 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_516stream_CMO(CYTHON_UNUSED PyObject *
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_CMO", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLMATHOLD", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_real);
+  __Pyx_XDECREF((PyObject *)__pyx_v_open);
+  __Pyx_XDECREF((PyObject *)__pyx_v_high);
+  __Pyx_XDECREF((PyObject *)__pyx_v_low);
+  __Pyx_XDECREF((PyObject *)__pyx_v_close);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -51990,135 +63102,209 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_516stream_CMO(CYTHON_UNUSED PyObject *
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_519stream_CORREL(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_518stream_CORREL[] = " CORREL(real0, real1[, timeperiod=?])\n\n    Pearson's Correlation Coefficient (r) (Statistic Functions)\n\n    Inputs:\n        real0: (any ndarray)\n        real1: (any ndarray)\n    Parameters:\n        timeperiod: 30\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_519stream_CORREL = {"stream_CORREL", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_519stream_CORREL, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_518stream_CORREL};
-static PyObject *__pyx_pw_5talib_7_ta_lib_519stream_CORREL(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_real0 = 0;
-  PyArrayObject *__pyx_v_real1 = 0;
-  int __pyx_v_timeperiod;
+static PyObject *__pyx_pw_5talib_7_ta_lib_487stream_CDLMORNINGDOJISTAR(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_486stream_CDLMORNINGDOJISTAR, "stream_CDLMORNINGDOJISTAR(ndarray open, ndarray high, ndarray low, ndarray close, double penetration=0.3)\n\nCDLMORNINGDOJISTAR(open, high, low, close[, penetration=?])\n\nMorning Doji Star (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nParameters:\n    penetration: 0.3\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_487stream_CDLMORNINGDOJISTAR = {"stream_CDLMORNINGDOJISTAR", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_487stream_CDLMORNINGDOJISTAR, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_486stream_CDLMORNINGDOJISTAR};
+static PyObject *__pyx_pw_5talib_7_ta_lib_487stream_CDLMORNINGDOJISTAR(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_open = 0;
+  PyArrayObject *__pyx_v_high = 0;
+  PyArrayObject *__pyx_v_low = 0;
+  PyArrayObject *__pyx_v_close = 0;
+  double __pyx_v_penetration;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[5] = {0,0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_CORREL (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_CDLMORNINGDOJISTAR (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real0,&__pyx_n_s_real1,&__pyx_n_s_timeperiod,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);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,&__pyx_mstate_global->__pyx_n_u_penetration,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 2169, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  5:
+        values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(5, 2169, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 2169, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 2169, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  0: break;
-        default: goto __pyx_L5_argtuple_error;
-      }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real0)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 2169, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real1)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_CORREL", 0, 2, 3, 1); __PYX_ERR(3, 2845, __pyx_L3_error)
-        }
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2169, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod);
-          if (value) { values[2] = value; kw_args--; }
-        }
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
       }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_CORREL") < 0)) __PYX_ERR(3, 2845, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLMORNINGDOJISTAR", 0) < (0)) __PYX_ERR(5, 2169, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLMORNINGDOJISTAR", 0, 4, 5, i); __PYX_ERR(5, 2169, __pyx_L3_error) }
       }
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+      switch (__pyx_nargs) {
+        case  5:
+        values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(5, 2169, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 2169, __pyx_L3_error)
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 2169, __pyx_L3_error)
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 2169, __pyx_L3_error)
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2169, __pyx_L3_error)
         break;
         default: goto __pyx_L5_argtuple_error;
       }
     }
-    __pyx_v_real0 = ((PyArrayObject *)values[0]);
-    __pyx_v_real1 = ((PyArrayObject *)values[1]);
-    if (values[2]) {
-      __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 2845, __pyx_L3_error)
+    __pyx_v_open = ((PyArrayObject *)values[0]);
+    __pyx_v_high = ((PyArrayObject *)values[1]);
+    __pyx_v_low = ((PyArrayObject *)values[2]);
+    __pyx_v_close = ((PyArrayObject *)values[3]);
+    if (values[4]) {
+      __pyx_v_penetration = __Pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_penetration == (double)-1) && PyErr_Occurred())) __PYX_ERR(5, 2171, __pyx_L3_error)
     } else {
-      __pyx_v_timeperiod = ((int)-2147483648);
+      __pyx_v_penetration = ((double)((double)0.3));
     }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_CORREL", 0, 2, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 2845, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_CDLMORNINGDOJISTAR", 0, 4, 5, __pyx_nargs); __PYX_ERR(5, 2169, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_CORREL", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLMORNINGDOJISTAR", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real0), __pyx_ptype_5numpy_ndarray, 0, "real0", 0))) __PYX_ERR(3, 2845, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real1), __pyx_ptype_5numpy_ndarray, 0, "real1", 0))) __PYX_ERR(3, 2845, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_518stream_CORREL(__pyx_self, __pyx_v_real0, __pyx_v_real1, __pyx_v_timeperiod);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 2171, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 2171, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 2171, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 2171, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_486stream_CDLMORNINGDOJISTAR(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_penetration);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_518stream_CORREL(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real0, PyArrayObject *__pyx_v_real1, int __pyx_v_timeperiod) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_486stream_CDLMORNINGDOJISTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
-  double *__pyx_v_real0_data;
-  double *__pyx_v_real1_data;
+  double *__pyx_v_open_data;
+  double *__pyx_v_high_data;
+  double *__pyx_v_low_data;
+  double *__pyx_v_close_data;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  double __pyx_v_outreal;
+  int __pyx_v_outinteger;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
-  __Pyx_RefNannySetupContext("stream_CORREL", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_real0);
-  __Pyx_INCREF((PyObject *)__pyx_v_real1);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_CDLMORNINGDOJISTAR", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_open);
+  __Pyx_INCREF((PyObject *)__pyx_v_high);
+  __Pyx_INCREF((PyObject *)__pyx_v_low);
+  __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2866, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2193, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_real0, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_real0_data = ((double *)__pyx_v_real0->data);
+  __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2868, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2195, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_real1, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
+
+  __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high));
+
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2197, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
+
+  __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low));
+
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2199, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_real1_data = ((double *)__pyx_v_real1->data);
+  __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close));
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_real0, __pyx_v_real1); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(3, 2870, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 2201, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
-  __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
+  __pyx_v_outinteger = 0;
 
-  __pyx_v_retCode = TA_CORREL((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real0_data, __pyx_v_real1_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
+  __pyx_v_retCode = TA_CDLMORNINGDOJISTAR((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, __pyx_v_penetration, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_CORREL, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2873, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLMORNINGDOJISTAR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2204, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2874, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2205, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -52128,11 +63314,13 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_518stream_CORREL(CYTHON_UNUSED PyObjec
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_CORREL", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLMORNINGDOJISTAR", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_real0);
-  __Pyx_XDECREF((PyObject *)__pyx_v_real1);
+  __Pyx_XDECREF((PyObject *)__pyx_v_open);
+  __Pyx_XDECREF((PyObject *)__pyx_v_high);
+  __Pyx_XDECREF((PyObject *)__pyx_v_low);
+  __Pyx_XDECREF((PyObject *)__pyx_v_close);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -52140,57 +63328,209 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_518stream_CORREL(CYTHON_UNUSED PyObjec
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_521stream_COS(PyObject *__pyx_self, PyObject *__pyx_v_real); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_520stream_COS[] = " COS(real)\n\n    Vector Trigonometric Cos (Math Transform)\n\n    Inputs:\n        real: (any ndarray)\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_521stream_COS = {"stream_COS", (PyCFunction)__pyx_pw_5talib_7_ta_lib_521stream_COS, METH_O, __pyx_doc_5talib_7_ta_lib_520stream_COS};
-static PyObject *__pyx_pw_5talib_7_ta_lib_521stream_COS(PyObject *__pyx_self, PyObject *__pyx_v_real) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_489stream_CDLMORNINGSTAR(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_488stream_CDLMORNINGSTAR, "stream_CDLMORNINGSTAR(ndarray open, ndarray high, ndarray low, ndarray close, double penetration=0.3)\n\nCDLMORNINGSTAR(open, high, low, close[, penetration=?])\n\nMorning Star (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nParameters:\n    penetration: 0.3\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_489stream_CDLMORNINGSTAR = {"stream_CDLMORNINGSTAR", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_489stream_CDLMORNINGSTAR, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_488stream_CDLMORNINGSTAR};
+static PyObject *__pyx_pw_5talib_7_ta_lib_489stream_CDLMORNINGSTAR(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_open = 0;
+  PyArrayObject *__pyx_v_high = 0;
+  PyArrayObject *__pyx_v_low = 0;
+  PyArrayObject *__pyx_v_close = 0;
+  double __pyx_v_penetration;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[5] = {0,0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_COS (wrapper)", 0);
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 2878, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_520stream_COS(__pyx_self, ((PyArrayObject *)__pyx_v_real));
+  __Pyx_RefNannySetupContext("stream_CDLMORNINGSTAR (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,&__pyx_mstate_global->__pyx_n_u_penetration,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 2207, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  5:
+        values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(5, 2207, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 2207, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 2207, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 2207, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2207, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLMORNINGSTAR", 0) < (0)) __PYX_ERR(5, 2207, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLMORNINGSTAR", 0, 4, 5, i); __PYX_ERR(5, 2207, __pyx_L3_error) }
+      }
+    } else {
+      switch (__pyx_nargs) {
+        case  5:
+        values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(5, 2207, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 2207, __pyx_L3_error)
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 2207, __pyx_L3_error)
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 2207, __pyx_L3_error)
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2207, __pyx_L3_error)
+        break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+    }
+    __pyx_v_open = ((PyArrayObject *)values[0]);
+    __pyx_v_high = ((PyArrayObject *)values[1]);
+    __pyx_v_low = ((PyArrayObject *)values[2]);
+    __pyx_v_close = ((PyArrayObject *)values[3]);
+    if (values[4]) {
+      __pyx_v_penetration = __Pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_penetration == (double)-1) && PyErr_Occurred())) __PYX_ERR(5, 2209, __pyx_L3_error)
+    } else {
+      __pyx_v_penetration = ((double)((double)0.3));
+    }
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("stream_CDLMORNINGSTAR", 0, 4, 5, __pyx_nargs); __PYX_ERR(5, 2207, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLMORNINGSTAR", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 2209, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 2209, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 2209, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 2209, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_488stream_CDLMORNINGSTAR(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_penetration);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_520stream_COS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_488stream_CDLMORNINGSTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, double __pyx_v_penetration) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
-  double *__pyx_v_real_data;
+  double *__pyx_v_open_data;
+  double *__pyx_v_high_data;
+  double *__pyx_v_low_data;
+  double *__pyx_v_close_data;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  double __pyx_v_outreal;
+  int __pyx_v_outinteger;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  __Pyx_RefNannySetupContext("stream_COS", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_real);
+  npy_intp __pyx_t_2;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_CDLMORNINGSTAR", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_open);
+  __Pyx_INCREF((PyObject *)__pyx_v_high);
+  __Pyx_INCREF((PyObject *)__pyx_v_low);
+  __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2895, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2231, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_real_data = ((double *)__pyx_v_real->data);
+  __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open));
+
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2233, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high));
 
-  __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2235, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_COS((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
+  __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_COS, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2900, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2237, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
+
+  __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close));
+
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 2239, __pyx_L1_error)
+  __pyx_v_length = __pyx_t_2;
+
+  __pyx_v_outinteger = 0;
+
+  __pyx_v_retCode = TA_CDLMORNINGSTAR((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, __pyx_v_penetration, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
+
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLMORNINGSTAR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2242, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2901, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2243, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -52200,10 +63540,13 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_520stream_COS(CYTHON_UNUSED PyObject *
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_COS", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLMORNINGSTAR", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_real);
+  __Pyx_XDECREF((PyObject *)__pyx_v_open);
+  __Pyx_XDECREF((PyObject *)__pyx_v_high);
+  __Pyx_XDECREF((PyObject *)__pyx_v_low);
+  __Pyx_XDECREF((PyObject *)__pyx_v_close);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -52211,57 +63554,192 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_520stream_COS(CYTHON_UNUSED PyObject *
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_523stream_COSH(PyObject *__pyx_self, PyObject *__pyx_v_real); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_522stream_COSH[] = " COSH(real)\n\n    Vector Trigonometric Cosh (Math Transform)\n\n    Inputs:\n        real: (any ndarray)\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_523stream_COSH = {"stream_COSH", (PyCFunction)__pyx_pw_5talib_7_ta_lib_523stream_COSH, METH_O, __pyx_doc_5talib_7_ta_lib_522stream_COSH};
-static PyObject *__pyx_pw_5talib_7_ta_lib_523stream_COSH(PyObject *__pyx_self, PyObject *__pyx_v_real) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_491stream_CDLONNECK(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_490stream_CDLONNECK, "stream_CDLONNECK(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLONNECK(open, high, low, close)\n\nOn-Neck Pattern (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_491stream_CDLONNECK = {"stream_CDLONNECK", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_491stream_CDLONNECK, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_490stream_CDLONNECK};
+static PyObject *__pyx_pw_5talib_7_ta_lib_491stream_CDLONNECK(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_open = 0;
+  PyArrayObject *__pyx_v_high = 0;
+  PyArrayObject *__pyx_v_low = 0;
+  PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_COSH (wrapper)", 0);
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 2905, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_522stream_COSH(__pyx_self, ((PyArrayObject *)__pyx_v_real));
-
-  /* function exit code */
-  goto __pyx_L0;
-  __pyx_L1_error:;
-  __pyx_r = NULL;
-  __pyx_L0:;
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-static PyObject *__pyx_pf_5talib_7_ta_lib_522stream_COSH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) {
-  npy_intp __pyx_v_length;
-  TA_RetCode __pyx_v_retCode;
-  double *__pyx_v_real_data;
-  int __pyx_v_outbegidx;
-  int __pyx_v_outnbelement;
-  double __pyx_v_outreal;
-  PyObject *__pyx_r = NULL;
-  __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
-  __Pyx_RefNannySetupContext("stream_COSH", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_real);
+  __Pyx_RefNannySetupContext("stream_CDLONNECK (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 2245, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 2245, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 2245, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 2245, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2245, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLONNECK", 0) < (0)) __PYX_ERR(5, 2245, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLONNECK", 1, 4, 4, i); __PYX_ERR(5, 2245, __pyx_L3_error) }
+      }
+    } else if (unlikely(__pyx_nargs != 4)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2245, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 2245, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 2245, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 2245, __pyx_L3_error)
+    }
+    __pyx_v_open = ((PyArrayObject *)values[0]);
+    __pyx_v_high = ((PyArrayObject *)values[1]);
+    __pyx_v_low = ((PyArrayObject *)values[2]);
+    __pyx_v_close = ((PyArrayObject *)values[3]);
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("stream_CDLONNECK", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 2245, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLONNECK", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 2247, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 2247, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 2247, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 2247, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_490stream_CDLONNECK(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
+  __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_5talib_7_ta_lib_490stream_CDLONNECK(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+  npy_intp __pyx_v_length;
+  TA_RetCode __pyx_v_retCode;
+  double *__pyx_v_open_data;
+  double *__pyx_v_high_data;
+  double *__pyx_v_low_data;
+  double *__pyx_v_close_data;
+  int __pyx_v_outbegidx;
+  int __pyx_v_outnbelement;
+  int __pyx_v_outinteger;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  npy_intp __pyx_t_2;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_CDLONNECK", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_open);
+  __Pyx_INCREF((PyObject *)__pyx_v_high);
+  __Pyx_INCREF((PyObject *)__pyx_v_low);
+  __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2922, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2267, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_real_data = ((double *)__pyx_v_real->data);
+  __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open));
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2269, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
 
-  __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
+  __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high));
 
-  __pyx_v_retCode = TA_COSH((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2271, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
+
+  __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low));
+
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2273, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
+
+  __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_COSH, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2927, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 2275, __pyx_L1_error)
+  __pyx_v_length = __pyx_t_2;
+
+  __pyx_v_outinteger = 0;
+
+  __pyx_v_retCode = TA_CDLONNECK((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
+
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLONNECK, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2278, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2928, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2279, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -52271,10 +63749,13 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_522stream_COSH(CYTHON_UNUSED PyObject
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_COSH", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLONNECK", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_real);
+  __Pyx_XDECREF((PyObject *)__pyx_v_open);
+  __Pyx_XDECREF((PyObject *)__pyx_v_high);
+  __Pyx_XDECREF((PyObject *)__pyx_v_low);
+  __Pyx_XDECREF((PyObject *)__pyx_v_close);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -52282,112 +63763,192 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_522stream_COSH(CYTHON_UNUSED PyObject
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_525stream_DEMA(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_524stream_DEMA[] = " DEMA(real[, timeperiod=?])\n\n    Double Exponential Moving Average (Overlap Studies)\n\n    Inputs:\n        real: (any ndarray)\n    Parameters:\n        timeperiod: 30\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_525stream_DEMA = {"stream_DEMA", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_525stream_DEMA, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_524stream_DEMA};
-static PyObject *__pyx_pw_5talib_7_ta_lib_525stream_DEMA(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_real = 0;
-  int __pyx_v_timeperiod;
+static PyObject *__pyx_pw_5talib_7_ta_lib_493stream_CDLPIERCING(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_492stream_CDLPIERCING, "stream_CDLPIERCING(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLPIERCING(open, high, low, close)\n\nPiercing Pattern (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_493stream_CDLPIERCING = {"stream_CDLPIERCING", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_493stream_CDLPIERCING, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_492stream_CDLPIERCING};
+static PyObject *__pyx_pw_5talib_7_ta_lib_493stream_CDLPIERCING(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_open = 0;
+  PyArrayObject *__pyx_v_high = 0;
+  PyArrayObject *__pyx_v_low = 0;
+  PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_DEMA (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_CDLPIERCING (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,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);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 2281, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 2281, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 2281, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  0: break;
-        default: goto __pyx_L5_argtuple_error;
-      }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 2281, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  1:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod);
-          if (value) { values[1] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_DEMA") < 0)) __PYX_ERR(3, 2932, __pyx_L3_error)
-      }
-    } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2281, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-        break;
+        case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-    }
-    __pyx_v_real = ((PyArrayObject *)values[0]);
-    if (values[1]) {
-      __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 2932, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLPIERCING", 0) < (0)) __PYX_ERR(5, 2281, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLPIERCING", 1, 4, 4, i); __PYX_ERR(5, 2281, __pyx_L3_error) }
+      }
+    } else if (unlikely(__pyx_nargs != 4)) {
+      goto __pyx_L5_argtuple_error;
     } else {
-      __pyx_v_timeperiod = ((int)-2147483648);
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2281, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 2281, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 2281, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 2281, __pyx_L3_error)
     }
+    __pyx_v_open = ((PyArrayObject *)values[0]);
+    __pyx_v_high = ((PyArrayObject *)values[1]);
+    __pyx_v_low = ((PyArrayObject *)values[2]);
+    __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_DEMA", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 2932, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_CDLPIERCING", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 2281, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_DEMA", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLPIERCING", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 2932, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_524stream_DEMA(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 2283, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 2283, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 2283, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 2283, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_492stream_CDLPIERCING(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_524stream_DEMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_492stream_CDLPIERCING(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
-  double *__pyx_v_real_data;
+  double *__pyx_v_open_data;
+  double *__pyx_v_high_data;
+  double *__pyx_v_low_data;
+  double *__pyx_v_close_data;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  double __pyx_v_outreal;
+  int __pyx_v_outinteger;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  __Pyx_RefNannySetupContext("stream_DEMA", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_real);
+  npy_intp __pyx_t_2;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_CDLPIERCING", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_open);
+  __Pyx_INCREF((PyObject *)__pyx_v_high);
+  __Pyx_INCREF((PyObject *)__pyx_v_low);
+  __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2951, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2303, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_real_data = ((double *)__pyx_v_real->data);
+  __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open));
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2305, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
 
-  __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
+  __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high));
 
-  __pyx_v_retCode = TA_DEMA((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2307, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
+
+  __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low));
+
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2309, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
+
+  __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_DEMA, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2956, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 2311, __pyx_L1_error)
+  __pyx_v_length = __pyx_t_2;
+
+  __pyx_v_outinteger = 0;
+
+  __pyx_v_retCode = TA_CDLPIERCING((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
+
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLPIERCING, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2314, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2957, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2315, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -52397,10 +63958,13 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_524stream_DEMA(CYTHON_UNUSED PyObject
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_DEMA", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLPIERCING", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_real);
+  __Pyx_XDECREF((PyObject *)__pyx_v_open);
+  __Pyx_XDECREF((PyObject *)__pyx_v_high);
+  __Pyx_XDECREF((PyObject *)__pyx_v_low);
+  __Pyx_XDECREF((PyObject *)__pyx_v_close);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -52408,117 +63972,192 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_524stream_DEMA(CYTHON_UNUSED PyObject
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_527stream_DIV(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_526stream_DIV[] = " DIV(real0, real1)\n\n    Vector Arithmetic Div (Math Operators)\n\n    Inputs:\n        real0: (any ndarray)\n        real1: (any ndarray)\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_527stream_DIV = {"stream_DIV", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_527stream_DIV, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_526stream_DIV};
-static PyObject *__pyx_pw_5talib_7_ta_lib_527stream_DIV(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_real0 = 0;
-  PyArrayObject *__pyx_v_real1 = 0;
+static PyObject *__pyx_pw_5talib_7_ta_lib_495stream_CDLRICKSHAWMAN(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_494stream_CDLRICKSHAWMAN, "stream_CDLRICKSHAWMAN(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLRICKSHAWMAN(open, high, low, close)\n\nRickshaw Man (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_495stream_CDLRICKSHAWMAN = {"stream_CDLRICKSHAWMAN", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_495stream_CDLRICKSHAWMAN, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_494stream_CDLRICKSHAWMAN};
+static PyObject *__pyx_pw_5talib_7_ta_lib_495stream_CDLRICKSHAWMAN(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_open = 0;
+  PyArrayObject *__pyx_v_high = 0;
+  PyArrayObject *__pyx_v_low = 0;
+  PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_DIV (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_CDLRICKSHAWMAN (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real0,&__pyx_n_s_real1,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);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 2317, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 2317, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 2317, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  0: break;
-        default: goto __pyx_L5_argtuple_error;
-      }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real0)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 2317, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real1)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_DIV", 1, 2, 2, 1); __PYX_ERR(3, 2961, __pyx_L3_error)
-        }
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2317, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
       }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_DIV") < 0)) __PYX_ERR(3, 2961, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLRICKSHAWMAN", 0) < (0)) __PYX_ERR(5, 2317, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLRICKSHAWMAN", 1, 4, 4, i); __PYX_ERR(5, 2317, __pyx_L3_error) }
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
+    } else if (unlikely(__pyx_nargs != 4)) {
       goto __pyx_L5_argtuple_error;
     } else {
-      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2317, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 2317, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 2317, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 2317, __pyx_L3_error)
     }
-    __pyx_v_real0 = ((PyArrayObject *)values[0]);
-    __pyx_v_real1 = ((PyArrayObject *)values[1]);
+    __pyx_v_open = ((PyArrayObject *)values[0]);
+    __pyx_v_high = ((PyArrayObject *)values[1]);
+    __pyx_v_low = ((PyArrayObject *)values[2]);
+    __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_DIV", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 2961, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_CDLRICKSHAWMAN", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 2317, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_DIV", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLRICKSHAWMAN", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real0), __pyx_ptype_5numpy_ndarray, 0, "real0", 0))) __PYX_ERR(3, 2961, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real1), __pyx_ptype_5numpy_ndarray, 0, "real1", 0))) __PYX_ERR(3, 2961, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_526stream_DIV(__pyx_self, __pyx_v_real0, __pyx_v_real1);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 2319, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 2319, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 2319, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 2319, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_494stream_CDLRICKSHAWMAN(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_526stream_DIV(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real0, PyArrayObject *__pyx_v_real1) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_494stream_CDLRICKSHAWMAN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
-  double *__pyx_v_real0_data;
-  double *__pyx_v_real1_data;
+  double *__pyx_v_open_data;
+  double *__pyx_v_high_data;
+  double *__pyx_v_low_data;
+  double *__pyx_v_close_data;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  double __pyx_v_outreal;
+  int __pyx_v_outinteger;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
-  __Pyx_RefNannySetupContext("stream_DIV", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_real0);
-  __Pyx_INCREF((PyObject *)__pyx_v_real1);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_CDLRICKSHAWMAN", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_open);
+  __Pyx_INCREF((PyObject *)__pyx_v_high);
+  __Pyx_INCREF((PyObject *)__pyx_v_low);
+  __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2980, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2339, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_real0, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_real0_data = ((double *)__pyx_v_real0->data);
+  __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2982, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2341, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_real1, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_real1_data = ((double *)__pyx_v_real1->data);
+  __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high));
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_real0, __pyx_v_real1); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(3, 2984, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2343, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
+
+  __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low));
+
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2345, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
+
+  __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close));
+
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 2347, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
-  __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
+  __pyx_v_outinteger = 0;
 
-  __pyx_v_retCode = TA_DIV((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real0_data, __pyx_v_real1_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
+  __pyx_v_retCode = TA_CDLRICKSHAWMAN((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_DIV, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2987, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLRICKSHAWMAN, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2350, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 2988, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2351, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -52528,11 +64167,13 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_526stream_DIV(CYTHON_UNUSED PyObject *
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_DIV", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLRICKSHAWMAN", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_real0);
-  __Pyx_XDECREF((PyObject *)__pyx_v_real1);
+  __Pyx_XDECREF((PyObject *)__pyx_v_open);
+  __Pyx_XDECREF((PyObject *)__pyx_v_high);
+  __Pyx_XDECREF((PyObject *)__pyx_v_low);
+  __Pyx_XDECREF((PyObject *)__pyx_v_close);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -52540,156 +64181,192 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_526stream_DIV(CYTHON_UNUSED PyObject *
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_529stream_DX(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_528stream_DX[] = " DX(high, low, close[, timeperiod=?])\n\n    Directional Movement Index (Momentum Indicators)\n\n    Inputs:\n        prices: ['high', 'low', 'close']\n    Parameters:\n        timeperiod: 14\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_529stream_DX = {"stream_DX", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_529stream_DX, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_528stream_DX};
-static PyObject *__pyx_pw_5talib_7_ta_lib_529stream_DX(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_497stream_CDLRISEFALL3METHODS(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_496stream_CDLRISEFALL3METHODS, "stream_CDLRISEFALL3METHODS(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLRISEFALL3METHODS(open, high, low, close)\n\nRising/Falling Three Methods (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_497stream_CDLRISEFALL3METHODS = {"stream_CDLRISEFALL3METHODS", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_497stream_CDLRISEFALL3METHODS, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_496stream_CDLRISEFALL3METHODS};
+static PyObject *__pyx_pw_5talib_7_ta_lib_497stream_CDLRISEFALL3METHODS(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_open = 0;
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
   PyArrayObject *__pyx_v_close = 0;
-  int __pyx_v_timeperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_DX (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_CDLRISEFALL3METHODS (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,&__pyx_n_s_timeperiod,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 2353, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 2353, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 2353, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 2353, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2353, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_DX", 0, 3, 4, 1); __PYX_ERR(3, 2992, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_DX", 0, 3, 4, 2); __PYX_ERR(3, 2992, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod);
-          if (value) { values[3] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_DX") < 0)) __PYX_ERR(3, 2992, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLRISEFALL3METHODS", 0) < (0)) __PYX_ERR(5, 2353, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLRISEFALL3METHODS", 1, 4, 4, i); __PYX_ERR(5, 2353, __pyx_L3_error) }
       }
+    } else if (unlikely(__pyx_nargs != 4)) {
+      goto __pyx_L5_argtuple_error;
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-        break;
-        default: goto __pyx_L5_argtuple_error;
-      }
-    }
-    __pyx_v_high = ((PyArrayObject *)values[0]);
-    __pyx_v_low = ((PyArrayObject *)values[1]);
-    __pyx_v_close = ((PyArrayObject *)values[2]);
-    if (values[3]) {
-      __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[3]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 2992, __pyx_L3_error)
-    } else {
-      __pyx_v_timeperiod = ((int)-2147483648);
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2353, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 2353, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 2353, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 2353, __pyx_L3_error)
     }
+    __pyx_v_open = ((PyArrayObject *)values[0]);
+    __pyx_v_high = ((PyArrayObject *)values[1]);
+    __pyx_v_low = ((PyArrayObject *)values[2]);
+    __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_DX", 0, 3, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 2992, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_CDLRISEFALL3METHODS", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 2353, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_DX", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLRISEFALL3METHODS", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 2992, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 2992, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 2992, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_528stream_DX(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_timeperiod);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 2355, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 2355, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 2355, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 2355, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_496stream_CDLRISEFALL3METHODS(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_528stream_DX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_496stream_CDLRISEFALL3METHODS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
+  double *__pyx_v_open_data;
   double *__pyx_v_high_data;
   double *__pyx_v_low_data;
   double *__pyx_v_close_data;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  double __pyx_v_outreal;
+  int __pyx_v_outinteger;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
-  __Pyx_RefNannySetupContext("stream_DX", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_CDLRISEFALL3METHODS", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_open);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
   __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3013, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2375, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
+
+  __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open));
+
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2377, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_high_data = ((double *)__pyx_v_high->data);
+  __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3015, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2379, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_low_data = ((double *)__pyx_v_low->data);
+  __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3017, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2381, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_close_data = ((double *)__pyx_v_close->data);
+  __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close));
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(3, 3019, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 2383, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
-  __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
+  __pyx_v_outinteger = 0;
 
-  __pyx_v_retCode = TA_DX((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
+  __pyx_v_retCode = TA_CDLRISEFALL3METHODS((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_DX, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3022, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLRISEFALL3METHODS, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2386, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3023, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2387, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -52699,9 +64376,10 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_528stream_DX(CYTHON_UNUSED PyObject *_
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_DX", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLRISEFALL3METHODS", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_open);
   __Pyx_XDECREF((PyObject *)__pyx_v_high);
   __Pyx_XDECREF((PyObject *)__pyx_v_low);
   __Pyx_XDECREF((PyObject *)__pyx_v_close);
@@ -52712,112 +64390,192 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_528stream_DX(CYTHON_UNUSED PyObject *_
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_531stream_EMA(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_530stream_EMA[] = " EMA(real[, timeperiod=?])\n\n    Exponential Moving Average (Overlap Studies)\n\n    Inputs:\n        real: (any ndarray)\n    Parameters:\n        timeperiod: 30\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_531stream_EMA = {"stream_EMA", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_531stream_EMA, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_530stream_EMA};
-static PyObject *__pyx_pw_5talib_7_ta_lib_531stream_EMA(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_real = 0;
-  int __pyx_v_timeperiod;
+static PyObject *__pyx_pw_5talib_7_ta_lib_499stream_CDLSEPARATINGLINES(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_498stream_CDLSEPARATINGLINES, "stream_CDLSEPARATINGLINES(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLSEPARATINGLINES(open, high, low, close)\n\nSeparating Lines (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_499stream_CDLSEPARATINGLINES = {"stream_CDLSEPARATINGLINES", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_499stream_CDLSEPARATINGLINES, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_498stream_CDLSEPARATINGLINES};
+static PyObject *__pyx_pw_5talib_7_ta_lib_499stream_CDLSEPARATINGLINES(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_open = 0;
+  PyArrayObject *__pyx_v_high = 0;
+  PyArrayObject *__pyx_v_low = 0;
+  PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_EMA (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_CDLSEPARATINGLINES (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,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);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 2389, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 2389, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 2389, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  0: break;
-        default: goto __pyx_L5_argtuple_error;
-      }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 2389, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  1:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod);
-          if (value) { values[1] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_EMA") < 0)) __PYX_ERR(3, 3027, __pyx_L3_error)
-      }
-    } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2389, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-        break;
+        case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-    }
-    __pyx_v_real = ((PyArrayObject *)values[0]);
-    if (values[1]) {
-      __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3027, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLSEPARATINGLINES", 0) < (0)) __PYX_ERR(5, 2389, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLSEPARATINGLINES", 1, 4, 4, i); __PYX_ERR(5, 2389, __pyx_L3_error) }
+      }
+    } else if (unlikely(__pyx_nargs != 4)) {
+      goto __pyx_L5_argtuple_error;
     } else {
-      __pyx_v_timeperiod = ((int)-2147483648);
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2389, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 2389, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 2389, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 2389, __pyx_L3_error)
     }
+    __pyx_v_open = ((PyArrayObject *)values[0]);
+    __pyx_v_high = ((PyArrayObject *)values[1]);
+    __pyx_v_low = ((PyArrayObject *)values[2]);
+    __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_EMA", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 3027, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_CDLSEPARATINGLINES", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 2389, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_EMA", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLSEPARATINGLINES", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 3027, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_530stream_EMA(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 2391, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 2391, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 2391, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 2391, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_498stream_CDLSEPARATINGLINES(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_530stream_EMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_498stream_CDLSEPARATINGLINES(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
-  double *__pyx_v_real_data;
+  double *__pyx_v_open_data;
+  double *__pyx_v_high_data;
+  double *__pyx_v_low_data;
+  double *__pyx_v_close_data;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  double __pyx_v_outreal;
+  int __pyx_v_outinteger;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  __Pyx_RefNannySetupContext("stream_EMA", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_real);
+  npy_intp __pyx_t_2;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_CDLSEPARATINGLINES", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_open);
+  __Pyx_INCREF((PyObject *)__pyx_v_high);
+  __Pyx_INCREF((PyObject *)__pyx_v_low);
+  __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3046, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2411, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
+
+  __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open));
+
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2413, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_real_data = ((double *)__pyx_v_real->data);
+  __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high));
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2415, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
 
-  __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
+  __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low));
 
-  __pyx_v_retCode = TA_EMA((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2417, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
+
+  __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close));
+
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 2419, __pyx_L1_error)
+  __pyx_v_length = __pyx_t_2;
+
+  __pyx_v_outinteger = 0;
+
+  __pyx_v_retCode = TA_CDLSEPARATINGLINES((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_EMA, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3051, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLSEPARATINGLINES, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2422, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3052, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2423, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -52827,10 +64585,13 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_530stream_EMA(CYTHON_UNUSED PyObject *
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_EMA", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLSEPARATINGLINES", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_real);
+  __Pyx_XDECREF((PyObject *)__pyx_v_open);
+  __Pyx_XDECREF((PyObject *)__pyx_v_high);
+  __Pyx_XDECREF((PyObject *)__pyx_v_low);
+  __Pyx_XDECREF((PyObject *)__pyx_v_close);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -52838,57 +64599,192 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_530stream_EMA(CYTHON_UNUSED PyObject *
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_533stream_EXP(PyObject *__pyx_self, PyObject *__pyx_v_real); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_532stream_EXP[] = " EXP(real)\n\n    Vector Arithmetic Exp (Math Transform)\n\n    Inputs:\n        real: (any ndarray)\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_533stream_EXP = {"stream_EXP", (PyCFunction)__pyx_pw_5talib_7_ta_lib_533stream_EXP, METH_O, __pyx_doc_5talib_7_ta_lib_532stream_EXP};
-static PyObject *__pyx_pw_5talib_7_ta_lib_533stream_EXP(PyObject *__pyx_self, PyObject *__pyx_v_real) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_501stream_CDLSHOOTINGSTAR(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_500stream_CDLSHOOTINGSTAR, "stream_CDLSHOOTINGSTAR(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLSHOOTINGSTAR(open, high, low, close)\n\nShooting Star (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_501stream_CDLSHOOTINGSTAR = {"stream_CDLSHOOTINGSTAR", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_501stream_CDLSHOOTINGSTAR, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_500stream_CDLSHOOTINGSTAR};
+static PyObject *__pyx_pw_5talib_7_ta_lib_501stream_CDLSHOOTINGSTAR(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_open = 0;
+  PyArrayObject *__pyx_v_high = 0;
+  PyArrayObject *__pyx_v_low = 0;
+  PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_EXP (wrapper)", 0);
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 3056, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_532stream_EXP(__pyx_self, ((PyArrayObject *)__pyx_v_real));
+  __Pyx_RefNannySetupContext("stream_CDLSHOOTINGSTAR (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 2425, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 2425, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 2425, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 2425, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2425, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLSHOOTINGSTAR", 0) < (0)) __PYX_ERR(5, 2425, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLSHOOTINGSTAR", 1, 4, 4, i); __PYX_ERR(5, 2425, __pyx_L3_error) }
+      }
+    } else if (unlikely(__pyx_nargs != 4)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2425, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 2425, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 2425, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 2425, __pyx_L3_error)
+    }
+    __pyx_v_open = ((PyArrayObject *)values[0]);
+    __pyx_v_high = ((PyArrayObject *)values[1]);
+    __pyx_v_low = ((PyArrayObject *)values[2]);
+    __pyx_v_close = ((PyArrayObject *)values[3]);
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("stream_CDLSHOOTINGSTAR", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 2425, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLSHOOTINGSTAR", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 2427, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 2427, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 2427, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 2427, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_500stream_CDLSHOOTINGSTAR(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_532stream_EXP(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_500stream_CDLSHOOTINGSTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
-  double *__pyx_v_real_data;
+  double *__pyx_v_open_data;
+  double *__pyx_v_high_data;
+  double *__pyx_v_low_data;
+  double *__pyx_v_close_data;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  double __pyx_v_outreal;
+  int __pyx_v_outinteger;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  __Pyx_RefNannySetupContext("stream_EXP", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_real);
+  npy_intp __pyx_t_2;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_CDLSHOOTINGSTAR", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_open);
+  __Pyx_INCREF((PyObject *)__pyx_v_high);
+  __Pyx_INCREF((PyObject *)__pyx_v_low);
+  __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3073, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2447, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
+
+  __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open));
+
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2449, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_real_data = ((double *)__pyx_v_real->data);
+  __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high));
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2451, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
 
-  __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
+  __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low));
 
-  __pyx_v_retCode = TA_EXP((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2453, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
+
+  __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close));
+
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 2455, __pyx_L1_error)
+  __pyx_v_length = __pyx_t_2;
+
+  __pyx_v_outinteger = 0;
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_EXP, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3078, __pyx_L1_error)
+  __pyx_v_retCode = TA_CDLSHOOTINGSTAR((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
+
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLSHOOTINGSTAR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2458, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3079, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2459, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -52898,10 +64794,13 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_532stream_EXP(CYTHON_UNUSED PyObject *
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_EXP", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLSHOOTINGSTAR", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_real);
+  __Pyx_XDECREF((PyObject *)__pyx_v_open);
+  __Pyx_XDECREF((PyObject *)__pyx_v_high);
+  __Pyx_XDECREF((PyObject *)__pyx_v_low);
+  __Pyx_XDECREF((PyObject *)__pyx_v_close);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -52909,128 +64808,192 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_532stream_EXP(CYTHON_UNUSED PyObject *
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_535stream_FLOOR(PyObject *__pyx_self, PyObject *__pyx_v_real); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_534stream_FLOOR[] = " FLOOR(real)\n\n    Vector Floor (Math Transform)\n\n    Inputs:\n        real: (any ndarray)\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_535stream_FLOOR = {"stream_FLOOR", (PyCFunction)__pyx_pw_5talib_7_ta_lib_535stream_FLOOR, METH_O, __pyx_doc_5talib_7_ta_lib_534stream_FLOOR};
-static PyObject *__pyx_pw_5talib_7_ta_lib_535stream_FLOOR(PyObject *__pyx_self, PyObject *__pyx_v_real) {
-  PyObject *__pyx_r = 0;
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_FLOOR (wrapper)", 0);
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 3083, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_534stream_FLOOR(__pyx_self, ((PyArrayObject *)__pyx_v_real));
-
-  /* function exit code */
-  goto __pyx_L0;
-  __pyx_L1_error:;
+static PyObject *__pyx_pw_5talib_7_ta_lib_503stream_CDLSHORTLINE(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_502stream_CDLSHORTLINE, "stream_CDLSHORTLINE(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLSHORTLINE(open, high, low, close)\n\nShort Line Candle (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_503stream_CDLSHORTLINE = {"stream_CDLSHORTLINE", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_503stream_CDLSHORTLINE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_502stream_CDLSHORTLINE};
+static PyObject *__pyx_pw_5talib_7_ta_lib_503stream_CDLSHORTLINE(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_open = 0;
+  PyArrayObject *__pyx_v_high = 0;
+  PyArrayObject *__pyx_v_low = 0;
+  PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("stream_CDLSHORTLINE (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 2461, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 2461, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 2461, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 2461, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2461, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLSHORTLINE", 0) < (0)) __PYX_ERR(5, 2461, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLSHORTLINE", 1, 4, 4, i); __PYX_ERR(5, 2461, __pyx_L3_error) }
+      }
+    } else if (unlikely(__pyx_nargs != 4)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2461, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 2461, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 2461, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 2461, __pyx_L3_error)
+    }
+    __pyx_v_open = ((PyArrayObject *)values[0]);
+    __pyx_v_high = ((PyArrayObject *)values[1]);
+    __pyx_v_low = ((PyArrayObject *)values[2]);
+    __pyx_v_close = ((PyArrayObject *)values[3]);
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("stream_CDLSHORTLINE", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 2461, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLSHORTLINE", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 2463, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 2463, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 2463, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 2463, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_502stream_CDLSHORTLINE(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_534stream_FLOOR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_502stream_CDLSHORTLINE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
-  double *__pyx_v_real_data;
+  double *__pyx_v_open_data;
+  double *__pyx_v_high_data;
+  double *__pyx_v_low_data;
+  double *__pyx_v_close_data;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  double __pyx_v_outreal;
+  int __pyx_v_outinteger;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  __Pyx_RefNannySetupContext("stream_FLOOR", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_real);
+  npy_intp __pyx_t_2;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_CDLSHORTLINE", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_open);
+  __Pyx_INCREF((PyObject *)__pyx_v_high);
+  __Pyx_INCREF((PyObject *)__pyx_v_low);
+  __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3100, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2483, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_real_data = ((double *)__pyx_v_real->data);
-
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
-
-  __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
-
-  __pyx_v_retCode = TA_FLOOR((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
-
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_FLOOR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3105, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open));
 
-  __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3106, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2485, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_r = __pyx_t_1;
+  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
-  goto __pyx_L0;
-
 
-  /* function exit code */
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_FLOOR", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = NULL;
-  __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_real);
-  __Pyx_XGIVEREF(__pyx_r);
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-
-/* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_537stream_HT_DCPERIOD(PyObject *__pyx_self, PyObject *__pyx_v_real); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_536stream_HT_DCPERIOD[] = " HT_DCPERIOD(real)\n\n    Hilbert Transform - Dominant Cycle Period (Cycle Indicators)\n\n    Inputs:\n        real: (any ndarray)\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_537stream_HT_DCPERIOD = {"stream_HT_DCPERIOD", (PyCFunction)__pyx_pw_5talib_7_ta_lib_537stream_HT_DCPERIOD, METH_O, __pyx_doc_5talib_7_ta_lib_536stream_HT_DCPERIOD};
-static PyObject *__pyx_pw_5talib_7_ta_lib_537stream_HT_DCPERIOD(PyObject *__pyx_self, PyObject *__pyx_v_real) {
-  PyObject *__pyx_r = 0;
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_HT_DCPERIOD (wrapper)", 0);
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 3110, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_536stream_HT_DCPERIOD(__pyx_self, ((PyArrayObject *)__pyx_v_real));
+  __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high));
 
-  /* function exit code */
-  goto __pyx_L0;
-  __pyx_L1_error:;
-  __pyx_r = NULL;
-  __pyx_L0:;
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2487, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_536stream_HT_DCPERIOD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) {
-  npy_intp __pyx_v_length;
-  TA_RetCode __pyx_v_retCode;
-  double *__pyx_v_real_data;
-  int __pyx_v_outbegidx;
-  int __pyx_v_outnbelement;
-  double __pyx_v_outreal;
-  PyObject *__pyx_r = NULL;
-  __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
-  __Pyx_RefNannySetupContext("stream_HT_DCPERIOD", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_real);
+  __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3127, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2489, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_real_data = ((double *)__pyx_v_real->data);
+  __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close));
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 2491, __pyx_L1_error)
+  __pyx_v_length = __pyx_t_2;
 
-  __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
+  __pyx_v_outinteger = 0;
 
-  __pyx_v_retCode = TA_HT_DCPERIOD((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
+  __pyx_v_retCode = TA_CDLSHORTLINE((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_HT_DCPERIOD, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3132, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLSHORTLINE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2494, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3133, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2495, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -53040,10 +65003,13 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_536stream_HT_DCPERIOD(CYTHON_UNUSED Py
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_HT_DCPERIOD", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLSHORTLINE", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_real);
+  __Pyx_XDECREF((PyObject *)__pyx_v_open);
+  __Pyx_XDECREF((PyObject *)__pyx_v_high);
+  __Pyx_XDECREF((PyObject *)__pyx_v_low);
+  __Pyx_XDECREF((PyObject *)__pyx_v_close);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -53051,57 +65017,192 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_536stream_HT_DCPERIOD(CYTHON_UNUSED Py
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_539stream_HT_DCPHASE(PyObject *__pyx_self, PyObject *__pyx_v_real); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_538stream_HT_DCPHASE[] = " HT_DCPHASE(real)\n\n    Hilbert Transform - Dominant Cycle Phase (Cycle Indicators)\n\n    Inputs:\n        real: (any ndarray)\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_539stream_HT_DCPHASE = {"stream_HT_DCPHASE", (PyCFunction)__pyx_pw_5talib_7_ta_lib_539stream_HT_DCPHASE, METH_O, __pyx_doc_5talib_7_ta_lib_538stream_HT_DCPHASE};
-static PyObject *__pyx_pw_5talib_7_ta_lib_539stream_HT_DCPHASE(PyObject *__pyx_self, PyObject *__pyx_v_real) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_505stream_CDLSPINNINGTOP(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_504stream_CDLSPINNINGTOP, "stream_CDLSPINNINGTOP(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLSPINNINGTOP(open, high, low, close)\n\nSpinning Top (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_505stream_CDLSPINNINGTOP = {"stream_CDLSPINNINGTOP", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_505stream_CDLSPINNINGTOP, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_504stream_CDLSPINNINGTOP};
+static PyObject *__pyx_pw_5talib_7_ta_lib_505stream_CDLSPINNINGTOP(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_open = 0;
+  PyArrayObject *__pyx_v_high = 0;
+  PyArrayObject *__pyx_v_low = 0;
+  PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_HT_DCPHASE (wrapper)", 0);
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 3137, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_538stream_HT_DCPHASE(__pyx_self, ((PyArrayObject *)__pyx_v_real));
+  __Pyx_RefNannySetupContext("stream_CDLSPINNINGTOP (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 2497, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 2497, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 2497, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 2497, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2497, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLSPINNINGTOP", 0) < (0)) __PYX_ERR(5, 2497, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLSPINNINGTOP", 1, 4, 4, i); __PYX_ERR(5, 2497, __pyx_L3_error) }
+      }
+    } else if (unlikely(__pyx_nargs != 4)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2497, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 2497, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 2497, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 2497, __pyx_L3_error)
+    }
+    __pyx_v_open = ((PyArrayObject *)values[0]);
+    __pyx_v_high = ((PyArrayObject *)values[1]);
+    __pyx_v_low = ((PyArrayObject *)values[2]);
+    __pyx_v_close = ((PyArrayObject *)values[3]);
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("stream_CDLSPINNINGTOP", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 2497, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLSPINNINGTOP", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 2499, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 2499, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 2499, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 2499, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_504stream_CDLSPINNINGTOP(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_538stream_HT_DCPHASE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_504stream_CDLSPINNINGTOP(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
-  double *__pyx_v_real_data;
+  double *__pyx_v_open_data;
+  double *__pyx_v_high_data;
+  double *__pyx_v_low_data;
+  double *__pyx_v_close_data;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  double __pyx_v_outreal;
+  int __pyx_v_outinteger;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  __Pyx_RefNannySetupContext("stream_HT_DCPHASE", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_real);
+  npy_intp __pyx_t_2;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_CDLSPINNINGTOP", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_open);
+  __Pyx_INCREF((PyObject *)__pyx_v_high);
+  __Pyx_INCREF((PyObject *)__pyx_v_low);
+  __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3154, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2519, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_real_data = ((double *)__pyx_v_real->data);
+  __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open));
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2521, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
 
-  __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
+  __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high));
 
-  __pyx_v_retCode = TA_HT_DCPHASE((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2523, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
+
+  __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low));
+
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2525, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_HT_DCPHASE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3159, __pyx_L1_error)
+  __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close));
+
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 2527, __pyx_L1_error)
+  __pyx_v_length = __pyx_t_2;
+
+  __pyx_v_outinteger = 0;
+
+  __pyx_v_retCode = TA_CDLSPINNINGTOP((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
+
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLSPINNINGTOP, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2530, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3160, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2531, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -53111,10 +65212,13 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_538stream_HT_DCPHASE(CYTHON_UNUSED PyO
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_HT_DCPHASE", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLSPINNINGTOP", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_real);
+  __Pyx_XDECREF((PyObject *)__pyx_v_open);
+  __Pyx_XDECREF((PyObject *)__pyx_v_high);
+  __Pyx_XDECREF((PyObject *)__pyx_v_low);
+  __Pyx_XDECREF((PyObject *)__pyx_v_close);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -53122,87 +65226,208 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_538stream_HT_DCPHASE(CYTHON_UNUSED PyO
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_541stream_HT_PHASOR(PyObject *__pyx_self, PyObject *__pyx_v_real); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_540stream_HT_PHASOR[] = " HT_PHASOR(real)\n\n    Hilbert Transform - Phasor Components (Cycle Indicators)\n\n    Inputs:\n        real: (any ndarray)\n    Outputs:\n        inphase\n        quadrature\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_541stream_HT_PHASOR = {"stream_HT_PHASOR", (PyCFunction)__pyx_pw_5talib_7_ta_lib_541stream_HT_PHASOR, METH_O, __pyx_doc_5talib_7_ta_lib_540stream_HT_PHASOR};
-static PyObject *__pyx_pw_5talib_7_ta_lib_541stream_HT_PHASOR(PyObject *__pyx_self, PyObject *__pyx_v_real) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_507stream_CDLSTALLEDPATTERN(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_506stream_CDLSTALLEDPATTERN, "stream_CDLSTALLEDPATTERN(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLSTALLEDPATTERN(open, high, low, close)\n\nStalled Pattern (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_507stream_CDLSTALLEDPATTERN = {"stream_CDLSTALLEDPATTERN", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_507stream_CDLSTALLEDPATTERN, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_506stream_CDLSTALLEDPATTERN};
+static PyObject *__pyx_pw_5talib_7_ta_lib_507stream_CDLSTALLEDPATTERN(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_open = 0;
+  PyArrayObject *__pyx_v_high = 0;
+  PyArrayObject *__pyx_v_low = 0;
+  PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_HT_PHASOR (wrapper)", 0);
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 3164, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_540stream_HT_PHASOR(__pyx_self, ((PyArrayObject *)__pyx_v_real));
+  __Pyx_RefNannySetupContext("stream_CDLSTALLEDPATTERN (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 2533, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 2533, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 2533, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 2533, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2533, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLSTALLEDPATTERN", 0) < (0)) __PYX_ERR(5, 2533, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLSTALLEDPATTERN", 1, 4, 4, i); __PYX_ERR(5, 2533, __pyx_L3_error) }
+      }
+    } else if (unlikely(__pyx_nargs != 4)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2533, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 2533, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 2533, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 2533, __pyx_L3_error)
+    }
+    __pyx_v_open = ((PyArrayObject *)values[0]);
+    __pyx_v_high = ((PyArrayObject *)values[1]);
+    __pyx_v_low = ((PyArrayObject *)values[2]);
+    __pyx_v_close = ((PyArrayObject *)values[3]);
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("stream_CDLSTALLEDPATTERN", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 2533, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLSTALLEDPATTERN", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 2535, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 2535, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 2535, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 2535, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_506stream_CDLSTALLEDPATTERN(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_540stream_HT_PHASOR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_506stream_CDLSTALLEDPATTERN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
-  double *__pyx_v_real_data;
+  double *__pyx_v_open_data;
+  double *__pyx_v_high_data;
+  double *__pyx_v_low_data;
+  double *__pyx_v_close_data;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  double __pyx_v_outinphase;
-  double __pyx_v_outquadrature;
+  int __pyx_v_outinteger;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  PyObject *__pyx_t_2 = NULL;
-  PyObject *__pyx_t_3 = NULL;
-  __Pyx_RefNannySetupContext("stream_HT_PHASOR", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_real);
+  npy_intp __pyx_t_2;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_CDLSTALLEDPATTERN", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_open);
+  __Pyx_INCREF((PyObject *)__pyx_v_high);
+  __Pyx_INCREF((PyObject *)__pyx_v_low);
+  __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3183, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2555, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
+
+  __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open));
+
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2557, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_real_data = ((double *)__pyx_v_real->data);
+  __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high));
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2559, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
 
-  __pyx_v_outinphase = __pyx_v_5talib_7_ta_lib_NaN;
+  __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low));
 
-  __pyx_v_outquadrature = __pyx_v_5talib_7_ta_lib_NaN;
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2561, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_HT_PHASOR((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinphase), (&__pyx_v_outquadrature));
+  __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close));
+
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 2563, __pyx_L1_error)
+  __pyx_v_length = __pyx_t_2;
+
+  __pyx_v_outinteger = 0;
+
+  __pyx_v_retCode = TA_CDLSTALLEDPATTERN((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_HT_PHASOR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3189, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLSTALLEDPATTERN, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2566, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outinphase); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3190, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2567, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = PyFloat_FromDouble(__pyx_v_outquadrature); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 3190, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3190, __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_r = __pyx_t_1;
   __pyx_t_1 = 0;
-  __pyx_t_2 = 0;
-  __pyx_r = __pyx_t_3;
-  __pyx_t_3 = 0;
   goto __pyx_L0;
 
 
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_XDECREF(__pyx_t_2);
-  __Pyx_XDECREF(__pyx_t_3);
-  __Pyx_AddTraceback("talib._ta_lib.stream_HT_PHASOR", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLSTALLEDPATTERN", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_real);
+  __Pyx_XDECREF((PyObject *)__pyx_v_open);
+  __Pyx_XDECREF((PyObject *)__pyx_v_high);
+  __Pyx_XDECREF((PyObject *)__pyx_v_low);
+  __Pyx_XDECREF((PyObject *)__pyx_v_close);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -53210,87 +65435,208 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_540stream_HT_PHASOR(CYTHON_UNUSED PyOb
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_543stream_HT_SINE(PyObject *__pyx_self, PyObject *__pyx_v_real); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_542stream_HT_SINE[] = " HT_SINE(real)\n\n    Hilbert Transform - SineWave (Cycle Indicators)\n\n    Inputs:\n        real: (any ndarray)\n    Outputs:\n        sine\n        leadsine\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_543stream_HT_SINE = {"stream_HT_SINE", (PyCFunction)__pyx_pw_5talib_7_ta_lib_543stream_HT_SINE, METH_O, __pyx_doc_5talib_7_ta_lib_542stream_HT_SINE};
-static PyObject *__pyx_pw_5talib_7_ta_lib_543stream_HT_SINE(PyObject *__pyx_self, PyObject *__pyx_v_real) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_509stream_CDLSTICKSANDWICH(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_508stream_CDLSTICKSANDWICH, "stream_CDLSTICKSANDWICH(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLSTICKSANDWICH(open, high, low, close)\n\nStick Sandwich (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_509stream_CDLSTICKSANDWICH = {"stream_CDLSTICKSANDWICH", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_509stream_CDLSTICKSANDWICH, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_508stream_CDLSTICKSANDWICH};
+static PyObject *__pyx_pw_5talib_7_ta_lib_509stream_CDLSTICKSANDWICH(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_open = 0;
+  PyArrayObject *__pyx_v_high = 0;
+  PyArrayObject *__pyx_v_low = 0;
+  PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_HT_SINE (wrapper)", 0);
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 3194, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_542stream_HT_SINE(__pyx_self, ((PyArrayObject *)__pyx_v_real));
+  __Pyx_RefNannySetupContext("stream_CDLSTICKSANDWICH (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 2569, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 2569, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 2569, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 2569, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2569, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLSTICKSANDWICH", 0) < (0)) __PYX_ERR(5, 2569, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLSTICKSANDWICH", 1, 4, 4, i); __PYX_ERR(5, 2569, __pyx_L3_error) }
+      }
+    } else if (unlikely(__pyx_nargs != 4)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2569, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 2569, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 2569, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 2569, __pyx_L3_error)
+    }
+    __pyx_v_open = ((PyArrayObject *)values[0]);
+    __pyx_v_high = ((PyArrayObject *)values[1]);
+    __pyx_v_low = ((PyArrayObject *)values[2]);
+    __pyx_v_close = ((PyArrayObject *)values[3]);
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("stream_CDLSTICKSANDWICH", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 2569, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLSTICKSANDWICH", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 2571, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 2571, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 2571, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 2571, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_508stream_CDLSTICKSANDWICH(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_542stream_HT_SINE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_508stream_CDLSTICKSANDWICH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
-  double *__pyx_v_real_data;
+  double *__pyx_v_open_data;
+  double *__pyx_v_high_data;
+  double *__pyx_v_low_data;
+  double *__pyx_v_close_data;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  double __pyx_v_outsine;
-  double __pyx_v_outleadsine;
+  int __pyx_v_outinteger;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  PyObject *__pyx_t_2 = NULL;
-  PyObject *__pyx_t_3 = NULL;
-  __Pyx_RefNannySetupContext("stream_HT_SINE", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_real);
+  npy_intp __pyx_t_2;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_CDLSTICKSANDWICH", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_open);
+  __Pyx_INCREF((PyObject *)__pyx_v_high);
+  __Pyx_INCREF((PyObject *)__pyx_v_low);
+  __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3213, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2591, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_real_data = ((double *)__pyx_v_real->data);
+  __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open));
+
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2593, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high));
 
-  __pyx_v_outsine = __pyx_v_5talib_7_ta_lib_NaN;
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2595, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
 
-  __pyx_v_outleadsine = __pyx_v_5talib_7_ta_lib_NaN;
+  __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low));
 
-  __pyx_v_retCode = TA_HT_SINE((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outsine), (&__pyx_v_outleadsine));
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2597, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
+
+  __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close));
+
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 2599, __pyx_L1_error)
+  __pyx_v_length = __pyx_t_2;
+
+  __pyx_v_outinteger = 0;
+
+  __pyx_v_retCode = TA_CDLSTICKSANDWICH((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_HT_SINE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3219, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLSTICKSANDWICH, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2602, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outsine); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3220, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2603, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = PyFloat_FromDouble(__pyx_v_outleadsine); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 3220, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3220, __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_r = __pyx_t_1;
   __pyx_t_1 = 0;
-  __pyx_t_2 = 0;
-  __pyx_r = __pyx_t_3;
-  __pyx_t_3 = 0;
   goto __pyx_L0;
 
 
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_XDECREF(__pyx_t_2);
-  __Pyx_XDECREF(__pyx_t_3);
-  __Pyx_AddTraceback("talib._ta_lib.stream_HT_SINE", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLSTICKSANDWICH", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_real);
+  __Pyx_XDECREF((PyObject *)__pyx_v_open);
+  __Pyx_XDECREF((PyObject *)__pyx_v_high);
+  __Pyx_XDECREF((PyObject *)__pyx_v_low);
+  __Pyx_XDECREF((PyObject *)__pyx_v_close);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -53298,57 +65644,192 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_542stream_HT_SINE(CYTHON_UNUSED PyObje
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_545stream_HT_TRENDLINE(PyObject *__pyx_self, PyObject *__pyx_v_real); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_544stream_HT_TRENDLINE[] = " HT_TRENDLINE(real)\n\n    Hilbert Transform - Instantaneous Trendline (Overlap Studies)\n\n    Inputs:\n        real: (any ndarray)\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_545stream_HT_TRENDLINE = {"stream_HT_TRENDLINE", (PyCFunction)__pyx_pw_5talib_7_ta_lib_545stream_HT_TRENDLINE, METH_O, __pyx_doc_5talib_7_ta_lib_544stream_HT_TRENDLINE};
-static PyObject *__pyx_pw_5talib_7_ta_lib_545stream_HT_TRENDLINE(PyObject *__pyx_self, PyObject *__pyx_v_real) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_511stream_CDLTAKURI(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_510stream_CDLTAKURI, "stream_CDLTAKURI(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLTAKURI(open, high, low, close)\n\nTakuri (Dragonfly Doji with very long lower shadow) (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_511stream_CDLTAKURI = {"stream_CDLTAKURI", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_511stream_CDLTAKURI, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_510stream_CDLTAKURI};
+static PyObject *__pyx_pw_5talib_7_ta_lib_511stream_CDLTAKURI(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_open = 0;
+  PyArrayObject *__pyx_v_high = 0;
+  PyArrayObject *__pyx_v_low = 0;
+  PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_HT_TRENDLINE (wrapper)", 0);
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 3224, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_544stream_HT_TRENDLINE(__pyx_self, ((PyArrayObject *)__pyx_v_real));
+  __Pyx_RefNannySetupContext("stream_CDLTAKURI (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 2605, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 2605, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 2605, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 2605, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2605, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLTAKURI", 0) < (0)) __PYX_ERR(5, 2605, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLTAKURI", 1, 4, 4, i); __PYX_ERR(5, 2605, __pyx_L3_error) }
+      }
+    } else if (unlikely(__pyx_nargs != 4)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2605, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 2605, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 2605, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 2605, __pyx_L3_error)
+    }
+    __pyx_v_open = ((PyArrayObject *)values[0]);
+    __pyx_v_high = ((PyArrayObject *)values[1]);
+    __pyx_v_low = ((PyArrayObject *)values[2]);
+    __pyx_v_close = ((PyArrayObject *)values[3]);
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("stream_CDLTAKURI", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 2605, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLTAKURI", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 2607, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 2607, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 2607, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 2607, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_510stream_CDLTAKURI(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_544stream_HT_TRENDLINE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_510stream_CDLTAKURI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
-  double *__pyx_v_real_data;
+  double *__pyx_v_open_data;
+  double *__pyx_v_high_data;
+  double *__pyx_v_low_data;
+  double *__pyx_v_close_data;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  double __pyx_v_outreal;
+  int __pyx_v_outinteger;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  __Pyx_RefNannySetupContext("stream_HT_TRENDLINE", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_real);
+  npy_intp __pyx_t_2;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_CDLTAKURI", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_open);
+  __Pyx_INCREF((PyObject *)__pyx_v_high);
+  __Pyx_INCREF((PyObject *)__pyx_v_low);
+  __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3241, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2627, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_real_data = ((double *)__pyx_v_real->data);
+  __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open));
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2629, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
 
-  __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
+  __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high));
 
-  __pyx_v_retCode = TA_HT_TRENDLINE((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2631, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_HT_TRENDLINE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3246, __pyx_L1_error)
+  __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low));
+
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2633, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
+
+  __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close));
+
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 2635, __pyx_L1_error)
+  __pyx_v_length = __pyx_t_2;
+
+  __pyx_v_outinteger = 0;
+
+  __pyx_v_retCode = TA_CDLTAKURI((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
+
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLTAKURI, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2638, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3247, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2639, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -53358,68 +65839,206 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_544stream_HT_TRENDLINE(CYTHON_UNUSED P
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_HT_TRENDLINE", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLTAKURI", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_real);
-  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_XDECREF((PyObject *)__pyx_v_open);
+  __Pyx_XDECREF((PyObject *)__pyx_v_high);
+  __Pyx_XDECREF((PyObject *)__pyx_v_low);
+  __Pyx_XDECREF((PyObject *)__pyx_v_close);
+  __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_547stream_HT_TRENDMODE(PyObject *__pyx_self, PyObject *__pyx_v_real); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_546stream_HT_TRENDMODE[] = " HT_TRENDMODE(real)\n\n    Hilbert Transform - Trend vs Cycle Mode (Cycle Indicators)\n\n    Inputs:\n        real: (any ndarray)\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_547stream_HT_TRENDMODE = {"stream_HT_TRENDMODE", (PyCFunction)__pyx_pw_5talib_7_ta_lib_547stream_HT_TRENDMODE, METH_O, __pyx_doc_5talib_7_ta_lib_546stream_HT_TRENDMODE};
-static PyObject *__pyx_pw_5talib_7_ta_lib_547stream_HT_TRENDMODE(PyObject *__pyx_self, PyObject *__pyx_v_real) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_513stream_CDLTASUKIGAP(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_512stream_CDLTASUKIGAP, "stream_CDLTASUKIGAP(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLTASUKIGAP(open, high, low, close)\n\nTasuki Gap (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_513stream_CDLTASUKIGAP = {"stream_CDLTASUKIGAP", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_513stream_CDLTASUKIGAP, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_512stream_CDLTASUKIGAP};
+static PyObject *__pyx_pw_5talib_7_ta_lib_513stream_CDLTASUKIGAP(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_open = 0;
+  PyArrayObject *__pyx_v_high = 0;
+  PyArrayObject *__pyx_v_low = 0;
+  PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_HT_TRENDMODE (wrapper)", 0);
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 3251, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_546stream_HT_TRENDMODE(__pyx_self, ((PyArrayObject *)__pyx_v_real));
+  __Pyx_RefNannySetupContext("stream_CDLTASUKIGAP (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 2641, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 2641, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 2641, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 2641, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2641, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLTASUKIGAP", 0) < (0)) __PYX_ERR(5, 2641, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLTASUKIGAP", 1, 4, 4, i); __PYX_ERR(5, 2641, __pyx_L3_error) }
+      }
+    } else if (unlikely(__pyx_nargs != 4)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2641, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 2641, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 2641, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 2641, __pyx_L3_error)
+    }
+    __pyx_v_open = ((PyArrayObject *)values[0]);
+    __pyx_v_high = ((PyArrayObject *)values[1]);
+    __pyx_v_low = ((PyArrayObject *)values[2]);
+    __pyx_v_close = ((PyArrayObject *)values[3]);
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("stream_CDLTASUKIGAP", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 2641, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLTASUKIGAP", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 2643, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 2643, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 2643, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 2643, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_512stream_CDLTASUKIGAP(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_546stream_HT_TRENDMODE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_512stream_CDLTASUKIGAP(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
-  double *__pyx_v_real_data;
+  double *__pyx_v_open_data;
+  double *__pyx_v_high_data;
+  double *__pyx_v_low_data;
+  double *__pyx_v_close_data;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
   int __pyx_v_outinteger;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  __Pyx_RefNannySetupContext("stream_HT_TRENDMODE", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_real);
+  npy_intp __pyx_t_2;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_CDLTASUKIGAP", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_open);
+  __Pyx_INCREF((PyObject *)__pyx_v_high);
+  __Pyx_INCREF((PyObject *)__pyx_v_low);
+  __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3268, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2663, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
+
+  __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open));
+
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2665, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
+
+  __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high));
+
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2667, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
+
+  __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low));
+
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2669, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_real_data = ((double *)__pyx_v_real->data);
+  __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close));
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 2671, __pyx_L1_error)
+  __pyx_v_length = __pyx_t_2;
 
   __pyx_v_outinteger = 0;
 
-  __pyx_v_retCode = TA_HT_TRENDMODE((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
+  __pyx_v_retCode = TA_CDLTASUKIGAP((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_HT_TRENDMODE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3273, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLTASUKIGAP, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2674, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3274, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2675, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -53429,10 +66048,13 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_546stream_HT_TRENDMODE(CYTHON_UNUSED P
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_HT_TRENDMODE", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLTASUKIGAP", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_real);
+  __Pyx_XDECREF((PyObject *)__pyx_v_open);
+  __Pyx_XDECREF((PyObject *)__pyx_v_high);
+  __Pyx_XDECREF((PyObject *)__pyx_v_low);
+  __Pyx_XDECREF((PyObject *)__pyx_v_close);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -53440,112 +66062,192 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_546stream_HT_TRENDMODE(CYTHON_UNUSED P
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_549stream_KAMA(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_548stream_KAMA[] = " KAMA(real[, timeperiod=?])\n\n    Kaufman Adaptive Moving Average (Overlap Studies)\n\n    Inputs:\n        real: (any ndarray)\n    Parameters:\n        timeperiod: 30\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_549stream_KAMA = {"stream_KAMA", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_549stream_KAMA, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_548stream_KAMA};
-static PyObject *__pyx_pw_5talib_7_ta_lib_549stream_KAMA(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_real = 0;
-  int __pyx_v_timeperiod;
+static PyObject *__pyx_pw_5talib_7_ta_lib_515stream_CDLTHRUSTING(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_514stream_CDLTHRUSTING, "stream_CDLTHRUSTING(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLTHRUSTING(open, high, low, close)\n\nThrusting Pattern (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_515stream_CDLTHRUSTING = {"stream_CDLTHRUSTING", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_515stream_CDLTHRUSTING, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_514stream_CDLTHRUSTING};
+static PyObject *__pyx_pw_5talib_7_ta_lib_515stream_CDLTHRUSTING(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_open = 0;
+  PyArrayObject *__pyx_v_high = 0;
+  PyArrayObject *__pyx_v_low = 0;
+  PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_KAMA (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_CDLTHRUSTING (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,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);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 2677, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 2677, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 2677, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  0: break;
-        default: goto __pyx_L5_argtuple_error;
-      }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 2677, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  1:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod);
-          if (value) { values[1] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_KAMA") < 0)) __PYX_ERR(3, 3278, __pyx_L3_error)
-      }
-    } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2677, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-        break;
+        case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-    }
-    __pyx_v_real = ((PyArrayObject *)values[0]);
-    if (values[1]) {
-      __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3278, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLTHRUSTING", 0) < (0)) __PYX_ERR(5, 2677, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLTHRUSTING", 1, 4, 4, i); __PYX_ERR(5, 2677, __pyx_L3_error) }
+      }
+    } else if (unlikely(__pyx_nargs != 4)) {
+      goto __pyx_L5_argtuple_error;
     } else {
-      __pyx_v_timeperiod = ((int)-2147483648);
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2677, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 2677, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 2677, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 2677, __pyx_L3_error)
     }
+    __pyx_v_open = ((PyArrayObject *)values[0]);
+    __pyx_v_high = ((PyArrayObject *)values[1]);
+    __pyx_v_low = ((PyArrayObject *)values[2]);
+    __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_KAMA", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 3278, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_CDLTHRUSTING", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 2677, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_KAMA", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLTHRUSTING", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 3278, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_548stream_KAMA(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 2679, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 2679, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 2679, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 2679, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_514stream_CDLTHRUSTING(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_548stream_KAMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_514stream_CDLTHRUSTING(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
-  double *__pyx_v_real_data;
+  double *__pyx_v_open_data;
+  double *__pyx_v_high_data;
+  double *__pyx_v_low_data;
+  double *__pyx_v_close_data;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  double __pyx_v_outreal;
+  int __pyx_v_outinteger;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  __Pyx_RefNannySetupContext("stream_KAMA", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_real);
+  npy_intp __pyx_t_2;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_CDLTHRUSTING", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_open);
+  __Pyx_INCREF((PyObject *)__pyx_v_high);
+  __Pyx_INCREF((PyObject *)__pyx_v_low);
+  __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3297, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2699, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_real_data = ((double *)__pyx_v_real->data);
+  __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open));
+
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2701, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high));
 
-  __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2703, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_KAMA((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
+  __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_KAMA, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3302, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2705, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
+
+  __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close));
+
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 2707, __pyx_L1_error)
+  __pyx_v_length = __pyx_t_2;
+
+  __pyx_v_outinteger = 0;
+
+  __pyx_v_retCode = TA_CDLTHRUSTING((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
+
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLTHRUSTING, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2710, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3303, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2711, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -53555,10 +66257,13 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_548stream_KAMA(CYTHON_UNUSED PyObject
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_KAMA", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLTHRUSTING", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_real);
+  __Pyx_XDECREF((PyObject *)__pyx_v_open);
+  __Pyx_XDECREF((PyObject *)__pyx_v_high);
+  __Pyx_XDECREF((PyObject *)__pyx_v_low);
+  __Pyx_XDECREF((PyObject *)__pyx_v_close);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -53566,112 +66271,192 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_548stream_KAMA(CYTHON_UNUSED PyObject
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_551stream_LINEARREG(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_550stream_LINEARREG[] = " LINEARREG(real[, timeperiod=?])\n\n    Linear Regression (Statistic Functions)\n\n    Inputs:\n        real: (any ndarray)\n    Parameters:\n        timeperiod: 14\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_551stream_LINEARREG = {"stream_LINEARREG", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_551stream_LINEARREG, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_550stream_LINEARREG};
-static PyObject *__pyx_pw_5talib_7_ta_lib_551stream_LINEARREG(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_real = 0;
-  int __pyx_v_timeperiod;
+static PyObject *__pyx_pw_5talib_7_ta_lib_517stream_CDLTRISTAR(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_516stream_CDLTRISTAR, "stream_CDLTRISTAR(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLTRISTAR(open, high, low, close)\n\nTristar Pattern (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_517stream_CDLTRISTAR = {"stream_CDLTRISTAR", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_517stream_CDLTRISTAR, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_516stream_CDLTRISTAR};
+static PyObject *__pyx_pw_5talib_7_ta_lib_517stream_CDLTRISTAR(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_open = 0;
+  PyArrayObject *__pyx_v_high = 0;
+  PyArrayObject *__pyx_v_low = 0;
+  PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_LINEARREG (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_CDLTRISTAR (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,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);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 2713, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 2713, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 2713, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  0: break;
-        default: goto __pyx_L5_argtuple_error;
-      }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 2713, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  1:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod);
-          if (value) { values[1] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_LINEARREG") < 0)) __PYX_ERR(3, 3307, __pyx_L3_error)
-      }
-    } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2713, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-        break;
+        case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-    }
-    __pyx_v_real = ((PyArrayObject *)values[0]);
-    if (values[1]) {
-      __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3307, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLTRISTAR", 0) < (0)) __PYX_ERR(5, 2713, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLTRISTAR", 1, 4, 4, i); __PYX_ERR(5, 2713, __pyx_L3_error) }
+      }
+    } else if (unlikely(__pyx_nargs != 4)) {
+      goto __pyx_L5_argtuple_error;
     } else {
-      __pyx_v_timeperiod = ((int)-2147483648);
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2713, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 2713, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 2713, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 2713, __pyx_L3_error)
     }
+    __pyx_v_open = ((PyArrayObject *)values[0]);
+    __pyx_v_high = ((PyArrayObject *)values[1]);
+    __pyx_v_low = ((PyArrayObject *)values[2]);
+    __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_LINEARREG", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 3307, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_CDLTRISTAR", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 2713, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_LINEARREG", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLTRISTAR", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 3307, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_550stream_LINEARREG(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 2715, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 2715, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 2715, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 2715, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_516stream_CDLTRISTAR(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_550stream_LINEARREG(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_516stream_CDLTRISTAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
-  double *__pyx_v_real_data;
+  double *__pyx_v_open_data;
+  double *__pyx_v_high_data;
+  double *__pyx_v_low_data;
+  double *__pyx_v_close_data;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  double __pyx_v_outreal;
+  int __pyx_v_outinteger;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  __Pyx_RefNannySetupContext("stream_LINEARREG", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_real);
+  npy_intp __pyx_t_2;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_CDLTRISTAR", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_open);
+  __Pyx_INCREF((PyObject *)__pyx_v_high);
+  __Pyx_INCREF((PyObject *)__pyx_v_low);
+  __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3326, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2735, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
+
+  __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open));
+
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2737, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_real_data = ((double *)__pyx_v_real->data);
+  __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high));
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2739, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
 
-  __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
+  __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low));
 
-  __pyx_v_retCode = TA_LINEARREG((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2741, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
+
+  __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close));
+
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 2743, __pyx_L1_error)
+  __pyx_v_length = __pyx_t_2;
+
+  __pyx_v_outinteger = 0;
+
+  __pyx_v_retCode = TA_CDLTRISTAR((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_LINEARREG, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3331, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLTRISTAR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2746, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3332, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2747, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -53681,10 +66466,13 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_550stream_LINEARREG(CYTHON_UNUSED PyOb
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_LINEARREG", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLTRISTAR", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_real);
+  __Pyx_XDECREF((PyObject *)__pyx_v_open);
+  __Pyx_XDECREF((PyObject *)__pyx_v_high);
+  __Pyx_XDECREF((PyObject *)__pyx_v_low);
+  __Pyx_XDECREF((PyObject *)__pyx_v_close);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -53692,112 +66480,192 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_550stream_LINEARREG(CYTHON_UNUSED PyOb
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_553stream_LINEARREG_ANGLE(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_552stream_LINEARREG_ANGLE[] = " LINEARREG_ANGLE(real[, timeperiod=?])\n\n    Linear Regression Angle (Statistic Functions)\n\n    Inputs:\n        real: (any ndarray)\n    Parameters:\n        timeperiod: 14\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_553stream_LINEARREG_ANGLE = {"stream_LINEARREG_ANGLE", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_553stream_LINEARREG_ANGLE, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_552stream_LINEARREG_ANGLE};
-static PyObject *__pyx_pw_5talib_7_ta_lib_553stream_LINEARREG_ANGLE(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_real = 0;
-  int __pyx_v_timeperiod;
+static PyObject *__pyx_pw_5talib_7_ta_lib_519stream_CDLUNIQUE3RIVER(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_518stream_CDLUNIQUE3RIVER, "stream_CDLUNIQUE3RIVER(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLUNIQUE3RIVER(open, high, low, close)\n\nUnique 3 River (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_519stream_CDLUNIQUE3RIVER = {"stream_CDLUNIQUE3RIVER", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_519stream_CDLUNIQUE3RIVER, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_518stream_CDLUNIQUE3RIVER};
+static PyObject *__pyx_pw_5talib_7_ta_lib_519stream_CDLUNIQUE3RIVER(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_open = 0;
+  PyArrayObject *__pyx_v_high = 0;
+  PyArrayObject *__pyx_v_low = 0;
+  PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_LINEARREG_ANGLE (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_CDLUNIQUE3RIVER (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,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);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 2749, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 2749, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 2749, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  0: break;
-        default: goto __pyx_L5_argtuple_error;
-      }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 2749, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  1:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod);
-          if (value) { values[1] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_LINEARREG_ANGLE") < 0)) __PYX_ERR(3, 3336, __pyx_L3_error)
-      }
-    } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2749, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-        break;
+        case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-    }
-    __pyx_v_real = ((PyArrayObject *)values[0]);
-    if (values[1]) {
-      __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3336, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLUNIQUE3RIVER", 0) < (0)) __PYX_ERR(5, 2749, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLUNIQUE3RIVER", 1, 4, 4, i); __PYX_ERR(5, 2749, __pyx_L3_error) }
+      }
+    } else if (unlikely(__pyx_nargs != 4)) {
+      goto __pyx_L5_argtuple_error;
     } else {
-      __pyx_v_timeperiod = ((int)-2147483648);
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2749, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 2749, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 2749, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 2749, __pyx_L3_error)
     }
+    __pyx_v_open = ((PyArrayObject *)values[0]);
+    __pyx_v_high = ((PyArrayObject *)values[1]);
+    __pyx_v_low = ((PyArrayObject *)values[2]);
+    __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_LINEARREG_ANGLE", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 3336, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_CDLUNIQUE3RIVER", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 2749, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_LINEARREG_ANGLE", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLUNIQUE3RIVER", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 3336, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_552stream_LINEARREG_ANGLE(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 2751, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 2751, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 2751, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 2751, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_518stream_CDLUNIQUE3RIVER(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_552stream_LINEARREG_ANGLE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_518stream_CDLUNIQUE3RIVER(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
-  double *__pyx_v_real_data;
+  double *__pyx_v_open_data;
+  double *__pyx_v_high_data;
+  double *__pyx_v_low_data;
+  double *__pyx_v_close_data;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  double __pyx_v_outreal;
+  int __pyx_v_outinteger;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  __Pyx_RefNannySetupContext("stream_LINEARREG_ANGLE", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_real);
+  npy_intp __pyx_t_2;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_CDLUNIQUE3RIVER", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_open);
+  __Pyx_INCREF((PyObject *)__pyx_v_high);
+  __Pyx_INCREF((PyObject *)__pyx_v_low);
+  __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3355, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2771, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_real_data = ((double *)__pyx_v_real->data);
+  __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open));
+
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2773, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high));
 
-  __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2775, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_LINEARREG_ANGLE((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
+  __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_LINEARREG_ANGLE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3360, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2777, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
+
+  __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close));
+
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 2779, __pyx_L1_error)
+  __pyx_v_length = __pyx_t_2;
+
+  __pyx_v_outinteger = 0;
+
+  __pyx_v_retCode = TA_CDLUNIQUE3RIVER((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
+
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLUNIQUE3RIVER, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2782, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3361, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2783, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -53807,10 +66675,13 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_552stream_LINEARREG_ANGLE(CYTHON_UNUSE
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_LINEARREG_ANGLE", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLUNIQUE3RIVER", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_real);
+  __Pyx_XDECREF((PyObject *)__pyx_v_open);
+  __Pyx_XDECREF((PyObject *)__pyx_v_high);
+  __Pyx_XDECREF((PyObject *)__pyx_v_low);
+  __Pyx_XDECREF((PyObject *)__pyx_v_close);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -53818,112 +66689,192 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_552stream_LINEARREG_ANGLE(CYTHON_UNUSE
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_555stream_LINEARREG_INTERCEPT(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_554stream_LINEARREG_INTERCEPT[] = " LINEARREG_INTERCEPT(real[, timeperiod=?])\n\n    Linear Regression Intercept (Statistic Functions)\n\n    Inputs:\n        real: (any ndarray)\n    Parameters:\n        timeperiod: 14\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_555stream_LINEARREG_INTERCEPT = {"stream_LINEARREG_INTERCEPT", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_555stream_LINEARREG_INTERCEPT, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_554stream_LINEARREG_INTERCEPT};
-static PyObject *__pyx_pw_5talib_7_ta_lib_555stream_LINEARREG_INTERCEPT(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_real = 0;
-  int __pyx_v_timeperiod;
+static PyObject *__pyx_pw_5talib_7_ta_lib_521stream_CDLUPSIDEGAP2CROWS(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_520stream_CDLUPSIDEGAP2CROWS, "stream_CDLUPSIDEGAP2CROWS(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLUPSIDEGAP2CROWS(open, high, low, close)\n\nUpside Gap Two Crows (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_521stream_CDLUPSIDEGAP2CROWS = {"stream_CDLUPSIDEGAP2CROWS", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_521stream_CDLUPSIDEGAP2CROWS, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_520stream_CDLUPSIDEGAP2CROWS};
+static PyObject *__pyx_pw_5talib_7_ta_lib_521stream_CDLUPSIDEGAP2CROWS(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_open = 0;
+  PyArrayObject *__pyx_v_high = 0;
+  PyArrayObject *__pyx_v_low = 0;
+  PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_LINEARREG_INTERCEPT (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_CDLUPSIDEGAP2CROWS (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,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);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 2785, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 2785, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 2785, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  0: break;
-        default: goto __pyx_L5_argtuple_error;
-      }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 2785, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  1:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod);
-          if (value) { values[1] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_LINEARREG_INTERCEPT") < 0)) __PYX_ERR(3, 3365, __pyx_L3_error)
-      }
-    } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2785, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-        break;
+        case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-    }
-    __pyx_v_real = ((PyArrayObject *)values[0]);
-    if (values[1]) {
-      __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3365, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLUPSIDEGAP2CROWS", 0) < (0)) __PYX_ERR(5, 2785, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLUPSIDEGAP2CROWS", 1, 4, 4, i); __PYX_ERR(5, 2785, __pyx_L3_error) }
+      }
+    } else if (unlikely(__pyx_nargs != 4)) {
+      goto __pyx_L5_argtuple_error;
     } else {
-      __pyx_v_timeperiod = ((int)-2147483648);
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2785, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 2785, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 2785, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 2785, __pyx_L3_error)
     }
+    __pyx_v_open = ((PyArrayObject *)values[0]);
+    __pyx_v_high = ((PyArrayObject *)values[1]);
+    __pyx_v_low = ((PyArrayObject *)values[2]);
+    __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_LINEARREG_INTERCEPT", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 3365, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_CDLUPSIDEGAP2CROWS", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 2785, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_LINEARREG_INTERCEPT", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLUPSIDEGAP2CROWS", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 3365, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_554stream_LINEARREG_INTERCEPT(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 2787, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 2787, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 2787, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 2787, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_520stream_CDLUPSIDEGAP2CROWS(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_554stream_LINEARREG_INTERCEPT(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_520stream_CDLUPSIDEGAP2CROWS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
-  double *__pyx_v_real_data;
+  double *__pyx_v_open_data;
+  double *__pyx_v_high_data;
+  double *__pyx_v_low_data;
+  double *__pyx_v_close_data;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  double __pyx_v_outreal;
+  int __pyx_v_outinteger;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  __Pyx_RefNannySetupContext("stream_LINEARREG_INTERCEPT", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_real);
+  npy_intp __pyx_t_2;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_CDLUPSIDEGAP2CROWS", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_open);
+  __Pyx_INCREF((PyObject *)__pyx_v_high);
+  __Pyx_INCREF((PyObject *)__pyx_v_low);
+  __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3384, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2807, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
+
+  __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open));
+
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2809, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_real_data = ((double *)__pyx_v_real->data);
+  __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high));
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2811, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
 
-  __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
+  __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low));
 
-  __pyx_v_retCode = TA_LINEARREG_INTERCEPT((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2813, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
+
+  __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close));
+
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 2815, __pyx_L1_error)
+  __pyx_v_length = __pyx_t_2;
+
+  __pyx_v_outinteger = 0;
+
+  __pyx_v_retCode = TA_CDLUPSIDEGAP2CROWS((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_LINEARREG_INTERCEPT, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3389, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLUPSIDEGAP2CROWS, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2818, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3390, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2819, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -53933,10 +66884,13 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_554stream_LINEARREG_INTERCEPT(CYTHON_U
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_LINEARREG_INTERCEPT", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLUPSIDEGAP2CROWS", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_real);
+  __Pyx_XDECREF((PyObject *)__pyx_v_open);
+  __Pyx_XDECREF((PyObject *)__pyx_v_high);
+  __Pyx_XDECREF((PyObject *)__pyx_v_low);
+  __Pyx_XDECREF((PyObject *)__pyx_v_close);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -53944,112 +66898,192 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_554stream_LINEARREG_INTERCEPT(CYTHON_U
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_557stream_LINEARREG_SLOPE(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_556stream_LINEARREG_SLOPE[] = " LINEARREG_SLOPE(real[, timeperiod=?])\n\n    Linear Regression Slope (Statistic Functions)\n\n    Inputs:\n        real: (any ndarray)\n    Parameters:\n        timeperiod: 14\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_557stream_LINEARREG_SLOPE = {"stream_LINEARREG_SLOPE", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_557stream_LINEARREG_SLOPE, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_556stream_LINEARREG_SLOPE};
-static PyObject *__pyx_pw_5talib_7_ta_lib_557stream_LINEARREG_SLOPE(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_real = 0;
-  int __pyx_v_timeperiod;
+static PyObject *__pyx_pw_5talib_7_ta_lib_523stream_CDLXSIDEGAP3METHODS(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_522stream_CDLXSIDEGAP3METHODS, "stream_CDLXSIDEGAP3METHODS(ndarray open, ndarray high, ndarray low, ndarray close)\n\nCDLXSIDEGAP3METHODS(open, high, low, close)\n\nUpside/Downside Gap Three Methods (Pattern Recognition)\n\nInputs:\n    prices: ['open', 'high', 'low', 'close']\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_523stream_CDLXSIDEGAP3METHODS = {"stream_CDLXSIDEGAP3METHODS", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_523stream_CDLXSIDEGAP3METHODS, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_522stream_CDLXSIDEGAP3METHODS};
+static PyObject *__pyx_pw_5talib_7_ta_lib_523stream_CDLXSIDEGAP3METHODS(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_open = 0;
+  PyArrayObject *__pyx_v_high = 0;
+  PyArrayObject *__pyx_v_low = 0;
+  PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_LINEARREG_SLOPE (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_CDLXSIDEGAP3METHODS (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,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);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 2821, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 2821, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 2821, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  0: break;
-        default: goto __pyx_L5_argtuple_error;
-      }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 2821, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  1:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod);
-          if (value) { values[1] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_LINEARREG_SLOPE") < 0)) __PYX_ERR(3, 3394, __pyx_L3_error)
-      }
-    } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2821, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-        break;
+        case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-    }
-    __pyx_v_real = ((PyArrayObject *)values[0]);
-    if (values[1]) {
-      __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3394, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CDLXSIDEGAP3METHODS", 0) < (0)) __PYX_ERR(5, 2821, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CDLXSIDEGAP3METHODS", 1, 4, 4, i); __PYX_ERR(5, 2821, __pyx_L3_error) }
+      }
+    } else if (unlikely(__pyx_nargs != 4)) {
+      goto __pyx_L5_argtuple_error;
     } else {
-      __pyx_v_timeperiod = ((int)-2147483648);
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2821, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 2821, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 2821, __pyx_L3_error)
+      values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 2821, __pyx_L3_error)
     }
+    __pyx_v_open = ((PyArrayObject *)values[0]);
+    __pyx_v_high = ((PyArrayObject *)values[1]);
+    __pyx_v_low = ((PyArrayObject *)values[2]);
+    __pyx_v_close = ((PyArrayObject *)values[3]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_LINEARREG_SLOPE", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 3394, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_CDLXSIDEGAP3METHODS", 1, 4, 4, __pyx_nargs); __PYX_ERR(5, 2821, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_LINEARREG_SLOPE", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLXSIDEGAP3METHODS", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 3394, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_556stream_LINEARREG_SLOPE(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 2823, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 2823, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 2823, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 2823, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_522stream_CDLXSIDEGAP3METHODS(__pyx_self, __pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_556stream_LINEARREG_SLOPE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_522stream_CDLXSIDEGAP3METHODS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
-  double *__pyx_v_real_data;
+  double *__pyx_v_open_data;
+  double *__pyx_v_high_data;
+  double *__pyx_v_low_data;
+  double *__pyx_v_close_data;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  double __pyx_v_outreal;
+  int __pyx_v_outinteger;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  __Pyx_RefNannySetupContext("stream_LINEARREG_SLOPE", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_real);
+  npy_intp __pyx_t_2;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_CDLXSIDEGAP3METHODS", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_open);
+  __Pyx_INCREF((PyObject *)__pyx_v_high);
+  __Pyx_INCREF((PyObject *)__pyx_v_low);
+  __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3413, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2843, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_real_data = ((double *)__pyx_v_real->data);
-
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open));
 
-  __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2845, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
 
-  __pyx_v_retCode = TA_LINEARREG_SLOPE((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
+  __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_LINEARREG_SLOPE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3418, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2847, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
+
+  __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low));
+
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2849, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
+
+  __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close));
+
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_open, __pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 2851, __pyx_L1_error)
+  __pyx_v_length = __pyx_t_2;
+
+  __pyx_v_outinteger = 0;
+
+  __pyx_v_retCode = TA_CDLXSIDEGAP3METHODS((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
+
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CDLXSIDEGAP3METHODS, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2854, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3419, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2855, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -54059,10 +67093,13 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_556stream_LINEARREG_SLOPE(CYTHON_UNUSE
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_LINEARREG_SLOPE", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_CDLXSIDEGAP3METHODS", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_real);
+  __Pyx_XDECREF((PyObject *)__pyx_v_open);
+  __Pyx_XDECREF((PyObject *)__pyx_v_high);
+  __Pyx_XDECREF((PyObject *)__pyx_v_low);
+  __Pyx_XDECREF((PyObject *)__pyx_v_close);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -54070,26 +67107,102 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_556stream_LINEARREG_SLOPE(CYTHON_UNUSE
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_559stream_LN(PyObject *__pyx_self, PyObject *__pyx_v_real); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_558stream_LN[] = " LN(real)\n\n    Vector Log Natural (Math Transform)\n\n    Inputs:\n        real: (any ndarray)\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_559stream_LN = {"stream_LN", (PyCFunction)__pyx_pw_5talib_7_ta_lib_559stream_LN, METH_O, __pyx_doc_5talib_7_ta_lib_558stream_LN};
-static PyObject *__pyx_pw_5talib_7_ta_lib_559stream_LN(PyObject *__pyx_self, PyObject *__pyx_v_real) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_525stream_CEIL(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_524stream_CEIL, "stream_CEIL(ndarray real)\n\nCEIL(real)\n\nVector Ceil (Math Transform)\n\nInputs:\n    real: (any ndarray)\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_525stream_CEIL = {"stream_CEIL", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_525stream_CEIL, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_524stream_CEIL};
+static PyObject *__pyx_pw_5talib_7_ta_lib_525stream_CEIL(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_real = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_LN (wrapper)", 0);
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 3423, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_558stream_LN(__pyx_self, ((PyArrayObject *)__pyx_v_real));
+  __Pyx_RefNannySetupContext("stream_CEIL (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 2857, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2857, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CEIL", 0) < (0)) __PYX_ERR(5, 2857, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CEIL", 1, 1, 1, i); __PYX_ERR(5, 2857, __pyx_L3_error) }
+      }
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2857, __pyx_L3_error)
+    }
+    __pyx_v_real = ((PyArrayObject *)values[0]);
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("stream_CEIL", 1, 1, 1, __pyx_nargs); __PYX_ERR(5, 2857, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_CEIL", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 2859, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_524stream_CEIL(__pyx_self, __pyx_v_real);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_558stream_LN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_524stream_CEIL(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
   double *__pyx_v_real_data;
@@ -54099,28 +67212,31 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_558stream_LN(CYTHON_UNUSED PyObject *_
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  __Pyx_RefNannySetupContext("stream_LN", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_CEIL", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3440, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2876, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_real_data = ((double *)__pyx_v_real->data);
+  __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real));
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
   __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
 
-  __pyx_v_retCode = TA_LN((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
+  __pyx_v_retCode = TA_CEIL((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_LN, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3445, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CEIL, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2881, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3446, __pyx_L1_error)
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2882, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -54130,7 +67246,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_558stream_LN(CYTHON_UNUSED PyObject *_
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_LN", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_CEIL", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_real);
@@ -54141,26 +67257,119 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_558stream_LN(CYTHON_UNUSED PyObject *_
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_561stream_LOG10(PyObject *__pyx_self, PyObject *__pyx_v_real); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_560stream_LOG10[] = " LOG10(real)\n\n    Vector Log10 (Math Transform)\n\n    Inputs:\n        real: (any ndarray)\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_561stream_LOG10 = {"stream_LOG10", (PyCFunction)__pyx_pw_5talib_7_ta_lib_561stream_LOG10, METH_O, __pyx_doc_5talib_7_ta_lib_560stream_LOG10};
-static PyObject *__pyx_pw_5talib_7_ta_lib_561stream_LOG10(PyObject *__pyx_self, PyObject *__pyx_v_real) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_527stream_CMO(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_526stream_CMO, "stream_CMO(ndarray real, int timeperiod=-0x80000000)\n\nCMO(real[, timeperiod=?])\n\nChande Momentum Oscillator (Momentum Indicators)\n\nInputs:\n    real: (any ndarray)\nParameters:\n    timeperiod: 14\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_527stream_CMO = {"stream_CMO", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_527stream_CMO, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_526stream_CMO};
+static PyObject *__pyx_pw_5talib_7_ta_lib_527stream_CMO(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_real = 0;
+  int __pyx_v_timeperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_LOG10 (wrapper)", 0);
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 3450, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_560stream_LOG10(__pyx_self, ((PyArrayObject *)__pyx_v_real));
+  __Pyx_RefNannySetupContext("stream_CMO (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 2884, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 2884, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2884, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CMO", 0) < (0)) __PYX_ERR(5, 2884, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CMO", 0, 1, 2, i); __PYX_ERR(5, 2884, __pyx_L3_error) }
+      }
+    } else {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 2884, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2884, __pyx_L3_error)
+        break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+    }
+    __pyx_v_real = ((PyArrayObject *)values[0]);
+    if (values[1]) {
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 2886, __pyx_L3_error)
+    } else {
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
+    }
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("stream_CMO", 0, 1, 2, __pyx_nargs); __PYX_ERR(5, 2884, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_CMO", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 2886, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_526stream_CMO(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_560stream_LOG10(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_526stream_CMO(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
   double *__pyx_v_real_data;
@@ -54170,28 +67379,31 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_560stream_LOG10(CYTHON_UNUSED PyObject
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  __Pyx_RefNannySetupContext("stream_LOG10", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_CMO", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3467, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2905, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_real_data = ((double *)__pyx_v_real->data);
+  __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real));
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
   __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
 
-  __pyx_v_retCode = TA_LOG10((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
+  __pyx_v_retCode = TA_CMO((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_LOG10, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3472, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CMO, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2910, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3473, __pyx_L1_error)
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2911, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -54201,7 +67413,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_560stream_LOG10(CYTHON_UNUSED PyObject
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_LOG10", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_CMO", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_real);
@@ -54212,128 +67424,173 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_560stream_LOG10(CYTHON_UNUSED PyObject
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_563stream_MA(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_562stream_MA[] = " MA(real[, timeperiod=?, matype=?])\n\n    Moving average (Overlap Studies)\n\n    Inputs:\n        real: (any ndarray)\n    Parameters:\n        timeperiod: 30\n        matype: 0 (Simple Moving Average)\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_563stream_MA = {"stream_MA", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_563stream_MA, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_562stream_MA};
-static PyObject *__pyx_pw_5talib_7_ta_lib_563stream_MA(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_real = 0;
+static PyObject *__pyx_pw_5talib_7_ta_lib_529stream_CORREL(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_528stream_CORREL, "stream_CORREL(ndarray real0, ndarray real1, int timeperiod=-0x80000000)\n\nCORREL(real0, real1[, timeperiod=?])\n\nPearson's Correlation Coefficient (r) (Statistic Functions)\n\nInputs:\n    real0: (any ndarray)\n    real1: (any ndarray)\nParameters:\n    timeperiod: 30\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_529stream_CORREL = {"stream_CORREL", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_529stream_CORREL, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_528stream_CORREL};
+static PyObject *__pyx_pw_5talib_7_ta_lib_529stream_CORREL(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_real0 = 0;
+  PyArrayObject *__pyx_v_real1 = 0;
   int __pyx_v_timeperiod;
-  int __pyx_v_matype;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[3] = {0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_MA (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_CORREL (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,&__pyx_n_s_matype,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);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real0,&__pyx_mstate_global->__pyx_n_u_real1,&__pyx_mstate_global->__pyx_n_u_timeperiod,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 2913, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 2913, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 2913, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2913, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod);
-          if (value) { values[1] = value; kw_args--; }
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_matype);
-          if (value) { values[2] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_MA") < 0)) __PYX_ERR(3, 3477, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_CORREL", 0) < (0)) __PYX_ERR(5, 2913, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_CORREL", 0, 2, 3, i); __PYX_ERR(5, 2913, __pyx_L3_error) }
       }
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      switch (__pyx_nargs) {
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 2913, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 2913, __pyx_L3_error)
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2913, __pyx_L3_error)
         break;
         default: goto __pyx_L5_argtuple_error;
       }
     }
-    __pyx_v_real = ((PyArrayObject *)values[0]);
-    if (values[1]) {
-      __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3477, __pyx_L3_error)
-    } else {
-      __pyx_v_timeperiod = ((int)-2147483648);
-    }
+    __pyx_v_real0 = ((PyArrayObject *)values[0]);
+    __pyx_v_real1 = ((PyArrayObject *)values[1]);
     if (values[2]) {
-      __pyx_v_matype = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_matype == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3477, __pyx_L3_error)
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[2]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 2915, __pyx_L3_error)
     } else {
-      __pyx_v_matype = ((int)0);
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
     }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_MA", 0, 1, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 3477, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_CORREL", 0, 2, 3, __pyx_nargs); __PYX_ERR(5, 2913, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_MA", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_CORREL", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 3477, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_562stream_MA(__pyx_self, __pyx_v_real, __pyx_v_timeperiod, __pyx_v_matype);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real0), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real0", 0))) __PYX_ERR(5, 2915, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real1), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real1", 0))) __PYX_ERR(5, 2915, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_528stream_CORREL(__pyx_self, __pyx_v_real0, __pyx_v_real1, __pyx_v_timeperiod);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_562stream_MA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod, int __pyx_v_matype) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_528stream_CORREL(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real0, PyArrayObject *__pyx_v_real1, int __pyx_v_timeperiod) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
-  double *__pyx_v_real_data;
+  double *__pyx_v_real0_data;
+  double *__pyx_v_real1_data;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
   double __pyx_v_outreal;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  __Pyx_RefNannySetupContext("stream_MA", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_real);
+  npy_intp __pyx_t_2;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_CORREL", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_real0);
+  __Pyx_INCREF((PyObject *)__pyx_v_real1);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3497, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2936, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_real0, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
+
+  __pyx_v_real0_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real0));
+
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2938, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_real1, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_real_data = ((double *)__pyx_v_real->data);
+  __pyx_v_real1_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real1));
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_real0, __pyx_v_real1); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 2940, __pyx_L1_error)
+  __pyx_v_length = __pyx_t_2;
 
   __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
 
-  __pyx_v_retCode = TA_MA((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, __pyx_v_matype, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
+  __pyx_v_retCode = TA_CORREL((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real0_data, __pyx_v_real1_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_MA, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3502, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_CORREL, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2943, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3503, __pyx_L1_error)
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2944, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -54343,10 +67600,11 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_562stream_MA(CYTHON_UNUSED PyObject *_
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_MA", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_CORREL", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_real);
+  __Pyx_XDECREF((PyObject *)__pyx_v_real0);
+  __Pyx_XDECREF((PyObject *)__pyx_v_real1);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -54354,181 +67612,146 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_562stream_MA(CYTHON_UNUSED PyObject *_
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_565stream_MACD(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_564stream_MACD[] = " MACD(real[, fastperiod=?, slowperiod=?, signalperiod=?])\n\n    Moving Average Convergence/Divergence (Momentum Indicators)\n\n    Inputs:\n        real: (any ndarray)\n    Parameters:\n        fastperiod: 12\n        slowperiod: 26\n        signalperiod: 9\n    Outputs:\n        macd\n        macdsignal\n        macdhist\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_565stream_MACD = {"stream_MACD", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_565stream_MACD, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_564stream_MACD};
-static PyObject *__pyx_pw_5talib_7_ta_lib_565stream_MACD(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_531stream_COS(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_530stream_COS, "stream_COS(ndarray real)\n\nCOS(real)\n\nVector Trigonometric Cos (Math Transform)\n\nInputs:\n    real: (any ndarray)\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_531stream_COS = {"stream_COS", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_531stream_COS, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_530stream_COS};
+static PyObject *__pyx_pw_5talib_7_ta_lib_531stream_COS(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_real = 0;
-  int __pyx_v_fastperiod;
-  int __pyx_v_slowperiod;
-  int __pyx_v_signalperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_MACD (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_COS (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_fastperiod,&__pyx_n_s_slowperiod,&__pyx_n_s_signalperiod,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 2946, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2946, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_fastperiod);
-          if (value) { values[1] = value; kw_args--; }
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_slowperiod);
-          if (value) { values[2] = value; kw_args--; }
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_signalperiod);
-          if (value) { values[3] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_MACD") < 0)) __PYX_ERR(3, 3507, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_COS", 0) < (0)) __PYX_ERR(5, 2946, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_COS", 1, 1, 1, i); __PYX_ERR(5, 2946, __pyx_L3_error) }
       }
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-        break;
-        default: goto __pyx_L5_argtuple_error;
-      }
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2946, __pyx_L3_error)
     }
     __pyx_v_real = ((PyArrayObject *)values[0]);
-    if (values[1]) {
-      __pyx_v_fastperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_fastperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3507, __pyx_L3_error)
-    } else {
-      __pyx_v_fastperiod = ((int)-2147483648);
-    }
-    if (values[2]) {
-      __pyx_v_slowperiod = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_slowperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3507, __pyx_L3_error)
-    } else {
-      __pyx_v_slowperiod = ((int)-2147483648);
-    }
-    if (values[3]) {
-      __pyx_v_signalperiod = __Pyx_PyInt_As_int(values[3]); if (unlikely((__pyx_v_signalperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3507, __pyx_L3_error)
-    } else {
-      __pyx_v_signalperiod = ((int)-2147483648);
-    }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_MACD", 0, 1, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 3507, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_COS", 1, 1, 1, __pyx_nargs); __PYX_ERR(5, 2946, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_MACD", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_COS", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 3507, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_564stream_MACD(__pyx_self, __pyx_v_real, __pyx_v_fastperiod, __pyx_v_slowperiod, __pyx_v_signalperiod);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 2948, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_530stream_COS(__pyx_self, __pyx_v_real);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_564stream_MACD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_fastperiod, int __pyx_v_slowperiod, int __pyx_v_signalperiod) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_530stream_COS(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
   double *__pyx_v_real_data;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  double __pyx_v_outmacd;
-  double __pyx_v_outmacdsignal;
-  double __pyx_v_outmacdhist;
+  double __pyx_v_outreal;
   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("stream_MACD", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_COS", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3532, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2965, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_real_data = ((double *)__pyx_v_real->data);
-
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
-
-  __pyx_v_outmacd = __pyx_v_5talib_7_ta_lib_NaN;
+  __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real));
 
-  __pyx_v_outmacdsignal = __pyx_v_5talib_7_ta_lib_NaN;
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
-  __pyx_v_outmacdhist = __pyx_v_5talib_7_ta_lib_NaN;
+  __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
 
-  __pyx_v_retCode = TA_MACD((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_fastperiod, __pyx_v_slowperiod, __pyx_v_signalperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outmacd), (&__pyx_v_outmacdsignal), (&__pyx_v_outmacdhist));
+  __pyx_v_retCode = TA_COS((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_MACD, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3539, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_COS, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2970, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outmacd); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3540, __pyx_L1_error)
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2971, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = PyFloat_FromDouble(__pyx_v_outmacdsignal); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 3540, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = PyFloat_FromDouble(__pyx_v_outmacdhist); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3540, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3540, __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_2);
-  PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_2);
-  __Pyx_GIVEREF(__pyx_t_3);
-  PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_t_3);
+  __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
-  __pyx_t_2 = 0;
-  __pyx_t_3 = 0;
-  __pyx_r = __pyx_t_4;
-  __pyx_t_4 = 0;
   goto __pyx_L0;
 
 
   /* 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("talib._ta_lib.stream_MACD", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_COS", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_real);
@@ -54539,229 +67762,146 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_564stream_MACD(CYTHON_UNUSED PyObject
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_567stream_MACDEXT(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_566stream_MACDEXT[] = " MACDEXT(real[, fastperiod=?, fastmatype=?, slowperiod=?, slowmatype=?, signalperiod=?, signalmatype=?])\n\n    MACD with controllable MA type (Momentum Indicators)\n\n    Inputs:\n        real: (any ndarray)\n    Parameters:\n        fastperiod: 12\n        fastmatype: 0\n        slowperiod: 26\n        slowmatype: 0\n        signalperiod: 9\n        signalmatype: 0\n    Outputs:\n        macd\n        macdsignal\n        macdhist\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_567stream_MACDEXT = {"stream_MACDEXT", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_567stream_MACDEXT, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_566stream_MACDEXT};
-static PyObject *__pyx_pw_5talib_7_ta_lib_567stream_MACDEXT(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_533stream_COSH(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_532stream_COSH, "stream_COSH(ndarray real)\n\nCOSH(real)\n\nVector Trigonometric Cosh (Math Transform)\n\nInputs:\n    real: (any ndarray)\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_533stream_COSH = {"stream_COSH", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_533stream_COSH, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_532stream_COSH};
+static PyObject *__pyx_pw_5talib_7_ta_lib_533stream_COSH(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_real = 0;
-  int __pyx_v_fastperiod;
-  int __pyx_v_fastmatype;
-  int __pyx_v_slowperiod;
-  int __pyx_v_slowmatype;
-  int __pyx_v_signalperiod;
-  int __pyx_v_signalmatype;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_MACDEXT (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_COSH (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_fastperiod,&__pyx_n_s_fastmatype,&__pyx_n_s_slowperiod,&__pyx_n_s_slowmatype,&__pyx_n_s_signalperiod,&__pyx_n_s_signalmatype,0};
-    PyObject* values[7] = {0,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  7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6);
-        CYTHON_FALLTHROUGH;
-        case  6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
-        CYTHON_FALLTHROUGH;
-        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
-        CYTHON_FALLTHROUGH;
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 2973, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2973, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_fastperiod);
-          if (value) { values[1] = value; kw_args--; }
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_fastmatype);
-          if (value) { values[2] = value; kw_args--; }
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_slowperiod);
-          if (value) { values[3] = value; kw_args--; }
-        }
-        CYTHON_FALLTHROUGH;
-        case  4:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_slowmatype);
-          if (value) { values[4] = value; kw_args--; }
-        }
-        CYTHON_FALLTHROUGH;
-        case  5:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_signalperiod);
-          if (value) { values[5] = value; kw_args--; }
-        }
-        CYTHON_FALLTHROUGH;
-        case  6:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_signalmatype);
-          if (value) { values[6] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_MACDEXT") < 0)) __PYX_ERR(3, 3544, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_COSH", 0) < (0)) __PYX_ERR(5, 2973, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_COSH", 1, 1, 1, i); __PYX_ERR(5, 2973, __pyx_L3_error) }
       }
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6);
-        CYTHON_FALLTHROUGH;
-        case  6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
-        CYTHON_FALLTHROUGH;
-        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
-        CYTHON_FALLTHROUGH;
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-        break;
-        default: goto __pyx_L5_argtuple_error;
-      }
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2973, __pyx_L3_error)
     }
     __pyx_v_real = ((PyArrayObject *)values[0]);
-    if (values[1]) {
-      __pyx_v_fastperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_fastperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3544, __pyx_L3_error)
-    } else {
-      __pyx_v_fastperiod = ((int)-2147483648);
-    }
-    if (values[2]) {
-      __pyx_v_fastmatype = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_fastmatype == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3544, __pyx_L3_error)
-    } else {
-      __pyx_v_fastmatype = ((int)0);
-    }
-    if (values[3]) {
-      __pyx_v_slowperiod = __Pyx_PyInt_As_int(values[3]); if (unlikely((__pyx_v_slowperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3544, __pyx_L3_error)
-    } else {
-      __pyx_v_slowperiod = ((int)-2147483648);
-    }
-    if (values[4]) {
-      __pyx_v_slowmatype = __Pyx_PyInt_As_int(values[4]); if (unlikely((__pyx_v_slowmatype == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3544, __pyx_L3_error)
-    } else {
-      __pyx_v_slowmatype = ((int)0);
-    }
-    if (values[5]) {
-      __pyx_v_signalperiod = __Pyx_PyInt_As_int(values[5]); if (unlikely((__pyx_v_signalperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3544, __pyx_L3_error)
-    } else {
-      __pyx_v_signalperiod = ((int)-2147483648);
-    }
-    if (values[6]) {
-      __pyx_v_signalmatype = __Pyx_PyInt_As_int(values[6]); if (unlikely((__pyx_v_signalmatype == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3544, __pyx_L3_error)
-    } else {
-      __pyx_v_signalmatype = ((int)0);
-    }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_MACDEXT", 0, 1, 7, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 3544, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_COSH", 1, 1, 1, __pyx_nargs); __PYX_ERR(5, 2973, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_MACDEXT", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_COSH", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 3544, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_566stream_MACDEXT(__pyx_self, __pyx_v_real, __pyx_v_fastperiod, __pyx_v_fastmatype, __pyx_v_slowperiod, __pyx_v_slowmatype, __pyx_v_signalperiod, __pyx_v_signalmatype);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 2975, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_532stream_COSH(__pyx_self, __pyx_v_real);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_566stream_MACDEXT(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_fastperiod, int __pyx_v_fastmatype, int __pyx_v_slowperiod, int __pyx_v_slowmatype, int __pyx_v_signalperiod, int __pyx_v_signalmatype) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_532stream_COSH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
   double *__pyx_v_real_data;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  double __pyx_v_outmacd;
-  double __pyx_v_outmacdsignal;
-  double __pyx_v_outmacdhist;
+  double __pyx_v_outreal;
   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("stream_MACDEXT", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_COSH", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3572, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2992, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_real_data = ((double *)__pyx_v_real->data);
+  __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real));
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
-  __pyx_v_outmacd = __pyx_v_5talib_7_ta_lib_NaN;
-
-  __pyx_v_outmacdsignal = __pyx_v_5talib_7_ta_lib_NaN;
-
-  __pyx_v_outmacdhist = __pyx_v_5talib_7_ta_lib_NaN;
+  __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
 
-  __pyx_v_retCode = TA_MACDEXT((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_fastperiod, __pyx_v_fastmatype, __pyx_v_slowperiod, __pyx_v_slowmatype, __pyx_v_signalperiod, __pyx_v_signalmatype, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outmacd), (&__pyx_v_outmacdsignal), (&__pyx_v_outmacdhist));
+  __pyx_v_retCode = TA_COSH((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_MACDEXT, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3579, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_COSH, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2997, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outmacd); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3580, __pyx_L1_error)
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2998, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = PyFloat_FromDouble(__pyx_v_outmacdsignal); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 3580, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = PyFloat_FromDouble(__pyx_v_outmacdhist); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3580, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3580, __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_2);
-  PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_2);
-  __Pyx_GIVEREF(__pyx_t_3);
-  PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_t_3);
+  __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
-  __pyx_t_2 = 0;
-  __pyx_t_3 = 0;
-  __pyx_r = __pyx_t_4;
-  __pyx_t_4 = 0;
   goto __pyx_L0;
 
 
   /* 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("talib._ta_lib.stream_MACDEXT", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_COSH", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_real);
@@ -54772,149 +67912,163 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_566stream_MACDEXT(CYTHON_UNUSED PyObje
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_569stream_MACDFIX(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_568stream_MACDFIX[] = " MACDFIX(real[, signalperiod=?])\n\n    Moving Average Convergence/Divergence Fix 12/26 (Momentum Indicators)\n\n    Inputs:\n        real: (any ndarray)\n    Parameters:\n        signalperiod: 9\n    Outputs:\n        macd\n        macdsignal\n        macdhist\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_569stream_MACDFIX = {"stream_MACDFIX", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_569stream_MACDFIX, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_568stream_MACDFIX};
-static PyObject *__pyx_pw_5talib_7_ta_lib_569stream_MACDFIX(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_535stream_DEMA(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_534stream_DEMA, "stream_DEMA(ndarray real, int timeperiod=-0x80000000)\n\nDEMA(real[, timeperiod=?])\n\nDouble Exponential Moving Average (Overlap Studies)\n\nInputs:\n    real: (any ndarray)\nParameters:\n    timeperiod: 30\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_535stream_DEMA = {"stream_DEMA", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_535stream_DEMA, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_534stream_DEMA};
+static PyObject *__pyx_pw_5talib_7_ta_lib_535stream_DEMA(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_real = 0;
-  int __pyx_v_signalperiod;
+  int __pyx_v_timeperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_MACDFIX (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_DEMA (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_signalperiod,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);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 3000, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 3000, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3000, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_signalperiod);
-          if (value) { values[1] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_MACDFIX") < 0)) __PYX_ERR(3, 3584, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_DEMA", 0) < (0)) __PYX_ERR(5, 3000, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_DEMA", 0, 1, 2, i); __PYX_ERR(5, 3000, __pyx_L3_error) }
       }
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 3000, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3000, __pyx_L3_error)
         break;
         default: goto __pyx_L5_argtuple_error;
       }
     }
     __pyx_v_real = ((PyArrayObject *)values[0]);
     if (values[1]) {
-      __pyx_v_signalperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_signalperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3584, __pyx_L3_error)
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 3002, __pyx_L3_error)
     } else {
-      __pyx_v_signalperiod = ((int)-2147483648);
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
     }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_MACDFIX", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 3584, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_DEMA", 0, 1, 2, __pyx_nargs); __PYX_ERR(5, 3000, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_MACDFIX", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_DEMA", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 3584, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_568stream_MACDFIX(__pyx_self, __pyx_v_real, __pyx_v_signalperiod);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 3002, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_534stream_DEMA(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_568stream_MACDFIX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_signalperiod) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_534stream_DEMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
   double *__pyx_v_real_data;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  double __pyx_v_outmacd;
-  double __pyx_v_outmacdsignal;
-  double __pyx_v_outmacdhist;
+  double __pyx_v_outreal;
   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("stream_MACDFIX", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_DEMA", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3607, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3021, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_real_data = ((double *)__pyx_v_real->data);
+  __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real));
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
-
-  __pyx_v_outmacd = __pyx_v_5talib_7_ta_lib_NaN;
-
-  __pyx_v_outmacdsignal = __pyx_v_5talib_7_ta_lib_NaN;
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
-  __pyx_v_outmacdhist = __pyx_v_5talib_7_ta_lib_NaN;
+  __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
 
-  __pyx_v_retCode = TA_MACDFIX((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_signalperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outmacd), (&__pyx_v_outmacdsignal), (&__pyx_v_outmacdhist));
+  __pyx_v_retCode = TA_DEMA((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_MACDFIX, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3614, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_DEMA, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3026, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outmacd); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3615, __pyx_L1_error)
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3027, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = PyFloat_FromDouble(__pyx_v_outmacdsignal); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 3615, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = PyFloat_FromDouble(__pyx_v_outmacdhist); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3615, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 3615, __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_2);
-  PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_2);
-  __Pyx_GIVEREF(__pyx_t_3);
-  PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_t_3);
+  __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
-  __pyx_t_2 = 0;
-  __pyx_t_3 = 0;
-  __pyx_r = __pyx_t_4;
-  __pyx_t_4 = 0;
   goto __pyx_L0;
 
 
   /* 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("talib._ta_lib.stream_MACDFIX", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_DEMA", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_real);
@@ -54925,158 +68079,170 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_568stream_MACDFIX(CYTHON_UNUSED PyObje
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_571stream_MAMA(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_570stream_MAMA[] = " MAMA(real[, fastlimit=?, slowlimit=?])\n\n    MESA Adaptive Moving Average (Overlap Studies)\n\n    Inputs:\n        real: (any ndarray)\n    Parameters:\n        fastlimit: 0.5\n        slowlimit: 0.05\n    Outputs:\n        mama\n        fama\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_571stream_MAMA = {"stream_MAMA", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_571stream_MAMA, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_570stream_MAMA};
-static PyObject *__pyx_pw_5talib_7_ta_lib_571stream_MAMA(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_real = 0;
-  double __pyx_v_fastlimit;
-  double __pyx_v_slowlimit;
+static PyObject *__pyx_pw_5talib_7_ta_lib_537stream_DIV(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_536stream_DIV, "stream_DIV(ndarray real0, ndarray real1)\n\nDIV(real0, real1)\n\nVector Arithmetic Div (Math Operators)\n\nInputs:\n    real0: (any ndarray)\n    real1: (any ndarray)\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_537stream_DIV = {"stream_DIV", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_537stream_DIV, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_536stream_DIV};
+static PyObject *__pyx_pw_5talib_7_ta_lib_537stream_DIV(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_real0 = 0;
+  PyArrayObject *__pyx_v_real1 = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_MAMA (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_DIV (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_fastlimit,&__pyx_n_s_slowlimit,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);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real0,&__pyx_mstate_global->__pyx_n_u_real1,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 3029, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 3029, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3029, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_fastlimit);
-          if (value) { values[1] = value; kw_args--; }
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_slowlimit);
-          if (value) { values[2] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_MAMA") < 0)) __PYX_ERR(3, 3619, __pyx_L3_error)
-      }
-    } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-        break;
-        default: goto __pyx_L5_argtuple_error;
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_DIV", 0) < (0)) __PYX_ERR(5, 3029, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_DIV", 1, 2, 2, i); __PYX_ERR(5, 3029, __pyx_L3_error) }
       }
-    }
-    __pyx_v_real = ((PyArrayObject *)values[0]);
-    if (values[1]) {
-      __pyx_v_fastlimit = __pyx_PyFloat_AsDouble(values[1]); if (unlikely((__pyx_v_fastlimit == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 3619, __pyx_L3_error)
-    } else {
-      __pyx_v_fastlimit = ((double)-4e37);
-    }
-    if (values[2]) {
-      __pyx_v_slowlimit = __pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_slowlimit == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 3619, __pyx_L3_error)
+    } else if (unlikely(__pyx_nargs != 2)) {
+      goto __pyx_L5_argtuple_error;
     } else {
-      __pyx_v_slowlimit = ((double)-4e37);
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3029, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 3029, __pyx_L3_error)
     }
+    __pyx_v_real0 = ((PyArrayObject *)values[0]);
+    __pyx_v_real1 = ((PyArrayObject *)values[1]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_MAMA", 0, 1, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 3619, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_DIV", 1, 2, 2, __pyx_nargs); __PYX_ERR(5, 3029, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_MAMA", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_DIV", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 3619, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_570stream_MAMA(__pyx_self, __pyx_v_real, __pyx_v_fastlimit, __pyx_v_slowlimit);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real0), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real0", 0))) __PYX_ERR(5, 3031, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real1), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real1", 0))) __PYX_ERR(5, 3031, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_536stream_DIV(__pyx_self, __pyx_v_real0, __pyx_v_real1);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_570stream_MAMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, double __pyx_v_fastlimit, double __pyx_v_slowlimit) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_536stream_DIV(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real0, PyArrayObject *__pyx_v_real1) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
-  double *__pyx_v_real_data;
+  double *__pyx_v_real0_data;
+  double *__pyx_v_real1_data;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  double __pyx_v_outmama;
-  double __pyx_v_outfama;
+  double __pyx_v_outreal;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  PyObject *__pyx_t_2 = NULL;
-  PyObject *__pyx_t_3 = NULL;
-  __Pyx_RefNannySetupContext("stream_MAMA", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_real);
+  npy_intp __pyx_t_2;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_DIV", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_real0);
+  __Pyx_INCREF((PyObject *)__pyx_v_real1);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3641, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3050, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_real0, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_real_data = ((double *)__pyx_v_real->data);
+  __pyx_v_real0_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real0));
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3052, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_real1, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
 
-  __pyx_v_outmama = __pyx_v_5talib_7_ta_lib_NaN;
+  __pyx_v_real1_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real1));
 
-  __pyx_v_outfama = __pyx_v_5talib_7_ta_lib_NaN;
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_real0, __pyx_v_real1); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 3054, __pyx_L1_error)
+  __pyx_v_length = __pyx_t_2;
 
-  __pyx_v_retCode = TA_MAMA((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_fastlimit, __pyx_v_slowlimit, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outmama), (&__pyx_v_outfama));
+  __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
+
+  __pyx_v_retCode = TA_DIV((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real0_data, __pyx_v_real1_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_MAMA, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3647, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_DIV, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3057, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outmama); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3648, __pyx_L1_error)
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3058, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = PyFloat_FromDouble(__pyx_v_outfama); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 3648, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3648, __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_r = __pyx_t_1;
   __pyx_t_1 = 0;
-  __pyx_t_2 = 0;
-  __pyx_r = __pyx_t_3;
-  __pyx_t_3 = 0;
   goto __pyx_L0;
 
 
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_XDECREF(__pyx_t_2);
-  __Pyx_XDECREF(__pyx_t_3);
-  __Pyx_AddTraceback("talib._ta_lib.stream_MAMA", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_DIV", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_real);
+  __Pyx_XDECREF((PyObject *)__pyx_v_real0);
+  __Pyx_XDECREF((PyObject *)__pyx_v_real1);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -55084,129 +68250,142 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_570stream_MAMA(CYTHON_UNUSED PyObject
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_573stream_MAVP(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_572stream_MAVP[] = " MAVP(real, periods[, minperiod=?, maxperiod=?, matype=?])\n\n    Moving average with variable period (Overlap Studies)\n\n    Inputs:\n        real: (any ndarray)\n        periods: (any ndarray)\n    Parameters:\n        minperiod: 2\n        maxperiod: 30\n        matype: 0 (Simple Moving Average)\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_573stream_MAVP = {"stream_MAVP", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_573stream_MAVP, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_572stream_MAVP};
-static PyObject *__pyx_pw_5talib_7_ta_lib_573stream_MAVP(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_real = 0;
-  PyArrayObject *__pyx_v_periods = 0;
-  int __pyx_v_minperiod;
-  int __pyx_v_maxperiod;
-  int __pyx_v_matype;
+static PyObject *__pyx_pw_5talib_7_ta_lib_539stream_DX(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_538stream_DX, "stream_DX(ndarray high, ndarray low, ndarray close, int timeperiod=-0x80000000)\n\nDX(high, low, close[, timeperiod=?])\n\nDirectional Movement Index (Momentum Indicators)\n\nInputs:\n    prices: ['high', 'low', 'close']\nParameters:\n    timeperiod: 14\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_539stream_DX = {"stream_DX", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_539stream_DX, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_538stream_DX};
+static PyObject *__pyx_pw_5talib_7_ta_lib_539stream_DX(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_high = 0;
+  PyArrayObject *__pyx_v_low = 0;
+  PyArrayObject *__pyx_v_close = 0;
+  int __pyx_v_timeperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_MAVP (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_DX (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_periods,&__pyx_n_s_minperiod,&__pyx_n_s_maxperiod,&__pyx_n_s_matype,0};
-    PyObject* values[5] = {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  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
-        CYTHON_FALLTHROUGH;
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,&__pyx_mstate_global->__pyx_n_u_timeperiod,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 3060, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 3060, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 3060, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 3060, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3060, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_periods)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_MAVP", 0, 2, 5, 1); __PYX_ERR(3, 3652, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_minperiod);
-          if (value) { values[2] = value; kw_args--; }
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_maxperiod);
-          if (value) { values[3] = value; kw_args--; }
-        }
-        CYTHON_FALLTHROUGH;
-        case  4:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_matype);
-          if (value) { values[4] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_MAVP") < 0)) __PYX_ERR(3, 3652, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_DX", 0) < (0)) __PYX_ERR(5, 3060, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 3; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_DX", 0, 3, 4, i); __PYX_ERR(5, 3060, __pyx_L3_error) }
       }
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
-        CYTHON_FALLTHROUGH;
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 3060, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 3060, __pyx_L3_error)
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 3060, __pyx_L3_error)
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3060, __pyx_L3_error)
         break;
         default: goto __pyx_L5_argtuple_error;
       }
     }
-    __pyx_v_real = ((PyArrayObject *)values[0]);
-    __pyx_v_periods = ((PyArrayObject *)values[1]);
-    if (values[2]) {
-      __pyx_v_minperiod = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_minperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3652, __pyx_L3_error)
-    } else {
-      __pyx_v_minperiod = ((int)-2147483648);
-    }
+    __pyx_v_high = ((PyArrayObject *)values[0]);
+    __pyx_v_low = ((PyArrayObject *)values[1]);
+    __pyx_v_close = ((PyArrayObject *)values[2]);
     if (values[3]) {
-      __pyx_v_maxperiod = __Pyx_PyInt_As_int(values[3]); if (unlikely((__pyx_v_maxperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3652, __pyx_L3_error)
-    } else {
-      __pyx_v_maxperiod = ((int)-2147483648);
-    }
-    if (values[4]) {
-      __pyx_v_matype = __Pyx_PyInt_As_int(values[4]); if (unlikely((__pyx_v_matype == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3652, __pyx_L3_error)
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[3]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 3062, __pyx_L3_error)
     } else {
-      __pyx_v_matype = ((int)0);
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
     }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_MAVP", 0, 2, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 3652, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_DX", 0, 3, 4, __pyx_nargs); __PYX_ERR(5, 3060, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_MAVP", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_DX", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 3652, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_periods), __pyx_ptype_5numpy_ndarray, 0, "periods", 0))) __PYX_ERR(3, 3652, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_572stream_MAVP(__pyx_self, __pyx_v_real, __pyx_v_periods, __pyx_v_minperiod, __pyx_v_maxperiod, __pyx_v_matype);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 3062, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 3062, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 3062, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_538stream_DX(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_timeperiod);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_572stream_MAVP(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, PyArrayObject *__pyx_v_periods, int __pyx_v_minperiod, int __pyx_v_maxperiod, int __pyx_v_matype) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_538stream_DX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
-  double *__pyx_v_real_data;
-  double *__pyx_v_periods_data;
+  double *__pyx_v_high_data;
+  double *__pyx_v_low_data;
+  double *__pyx_v_close_data;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
   double __pyx_v_outreal;
@@ -55214,37 +68393,48 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_572stream_MAVP(CYTHON_UNUSED PyObject
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
-  __Pyx_RefNannySetupContext("stream_MAVP", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_real);
-  __Pyx_INCREF((PyObject *)__pyx_v_periods);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_DX", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_high);
+  __Pyx_INCREF((PyObject *)__pyx_v_low);
+  __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3675, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3083, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_real_data = ((double *)__pyx_v_real->data);
+  __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_periods)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3677, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3085, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_periods, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
+
+  __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low));
+
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3087, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_periods_data = ((double *)__pyx_v_periods->data);
+  __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close));
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_real, __pyx_v_periods); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(3, 3679, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 3089, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
   __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
 
-  __pyx_v_retCode = TA_MAVP((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_periods_data, __pyx_v_minperiod, __pyx_v_maxperiod, __pyx_v_matype, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
+  __pyx_v_retCode = TA_DX((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_MAVP, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3682, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_DX, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3092, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3683, __pyx_L1_error)
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3093, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -55254,11 +68444,12 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_572stream_MAVP(CYTHON_UNUSED PyObject
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_MAVP", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_DX", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_real);
-  __Pyx_XDECREF((PyObject *)__pyx_v_periods);
+  __Pyx_XDECREF((PyObject *)__pyx_v_high);
+  __Pyx_XDECREF((PyObject *)__pyx_v_low);
+  __Pyx_XDECREF((PyObject *)__pyx_v_close);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -55266,81 +68457,119 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_572stream_MAVP(CYTHON_UNUSED PyObject
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_575stream_MAX(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_574stream_MAX[] = " MAX(real[, timeperiod=?])\n\n    Highest value over a specified period (Math Operators)\n\n    Inputs:\n        real: (any ndarray)\n    Parameters:\n        timeperiod: 30\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_575stream_MAX = {"stream_MAX", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_575stream_MAX, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_574stream_MAX};
-static PyObject *__pyx_pw_5talib_7_ta_lib_575stream_MAX(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_541stream_EMA(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_540stream_EMA, "stream_EMA(ndarray real, int timeperiod=-0x80000000)\n\nEMA(real[, timeperiod=?])\n\nExponential Moving Average (Overlap Studies)\n\nInputs:\n    real: (any ndarray)\nParameters:\n    timeperiod: 30\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_541stream_EMA = {"stream_EMA", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_541stream_EMA, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_540stream_EMA};
+static PyObject *__pyx_pw_5talib_7_ta_lib_541stream_EMA(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_real = 0;
   int __pyx_v_timeperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_MAX (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_EMA (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,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);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 3095, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 3095, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3095, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod);
-          if (value) { values[1] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_MAX") < 0)) __PYX_ERR(3, 3687, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_EMA", 0) < (0)) __PYX_ERR(5, 3095, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_EMA", 0, 1, 2, i); __PYX_ERR(5, 3095, __pyx_L3_error) }
       }
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 3095, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3095, __pyx_L3_error)
         break;
         default: goto __pyx_L5_argtuple_error;
       }
     }
     __pyx_v_real = ((PyArrayObject *)values[0]);
     if (values[1]) {
-      __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3687, __pyx_L3_error)
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 3097, __pyx_L3_error)
     } else {
-      __pyx_v_timeperiod = ((int)-2147483648);
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
     }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_MAX", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 3687, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_EMA", 0, 1, 2, __pyx_nargs); __PYX_ERR(5, 3095, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_MAX", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_EMA", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 3687, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_574stream_MAX(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 3097, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_540stream_EMA(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_574stream_MAX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_540stream_EMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
   double *__pyx_v_real_data;
@@ -55350,28 +68579,31 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_574stream_MAX(CYTHON_UNUSED PyObject *
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  __Pyx_RefNannySetupContext("stream_MAX", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_EMA", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3706, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3116, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_real_data = ((double *)__pyx_v_real->data);
+  __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real));
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
   __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
 
-  __pyx_v_retCode = TA_MAX((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
+  __pyx_v_retCode = TA_EMA((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_MAX, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3711, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_EMA, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3121, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3712, __pyx_L1_error)
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3122, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -55381,7 +68613,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_574stream_MAX(CYTHON_UNUSED PyObject *
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_MAX", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_EMA", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_real);
@@ -55392,112 +68624,136 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_574stream_MAX(CYTHON_UNUSED PyObject *
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_577stream_MAXINDEX(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_576stream_MAXINDEX[] = " MAXINDEX(real[, timeperiod=?])\n\n    Index of highest value over a specified period (Math Operators)\n\n    Inputs:\n        real: (any ndarray)\n    Parameters:\n        timeperiod: 30\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_577stream_MAXINDEX = {"stream_MAXINDEX", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_577stream_MAXINDEX, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_576stream_MAXINDEX};
-static PyObject *__pyx_pw_5talib_7_ta_lib_577stream_MAXINDEX(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_543stream_EXP(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_542stream_EXP, "stream_EXP(ndarray real)\n\nEXP(real)\n\nVector Arithmetic Exp (Math Transform)\n\nInputs:\n    real: (any ndarray)\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_543stream_EXP = {"stream_EXP", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_543stream_EXP, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_542stream_EXP};
+static PyObject *__pyx_pw_5talib_7_ta_lib_543stream_EXP(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_real = 0;
-  int __pyx_v_timeperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_MAXINDEX (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_EXP (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,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);
-        CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 3124, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3124, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod);
-          if (value) { values[1] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_MAXINDEX") < 0)) __PYX_ERR(3, 3716, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_EXP", 0) < (0)) __PYX_ERR(5, 3124, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_EXP", 1, 1, 1, i); __PYX_ERR(5, 3124, __pyx_L3_error) }
       }
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-        break;
-        default: goto __pyx_L5_argtuple_error;
-      }
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3124, __pyx_L3_error)
     }
     __pyx_v_real = ((PyArrayObject *)values[0]);
-    if (values[1]) {
-      __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3716, __pyx_L3_error)
-    } else {
-      __pyx_v_timeperiod = ((int)-2147483648);
-    }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_MAXINDEX", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 3716, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_EXP", 1, 1, 1, __pyx_nargs); __PYX_ERR(5, 3124, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_MAXINDEX", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_EXP", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 3716, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_576stream_MAXINDEX(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 3126, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_542stream_EXP(__pyx_self, __pyx_v_real);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_576stream_MAXINDEX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_542stream_EXP(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
   double *__pyx_v_real_data;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  int __pyx_v_outinteger;
+  double __pyx_v_outreal;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  __Pyx_RefNannySetupContext("stream_MAXINDEX", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_EXP", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3735, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3143, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_real_data = ((double *)__pyx_v_real->data);
+  __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real));
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
-  __pyx_v_outinteger = 0;
+  __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
 
-  __pyx_v_retCode = TA_MAXINDEX((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
+  __pyx_v_retCode = TA_EXP((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_MAXINDEX, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3740, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_EXP, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3148, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3741, __pyx_L1_error)
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3149, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -55507,7 +68763,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_576stream_MAXINDEX(CYTHON_UNUSED PyObj
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_MAXINDEX", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_EXP", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_real);
@@ -55518,117 +68774,136 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_576stream_MAXINDEX(CYTHON_UNUSED PyObj
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_579stream_MEDPRICE(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_578stream_MEDPRICE[] = " MEDPRICE(high, low)\n\n    Median Price (Price Transform)\n\n    Inputs:\n        prices: ['high', 'low']\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_579stream_MEDPRICE = {"stream_MEDPRICE", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_579stream_MEDPRICE, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_578stream_MEDPRICE};
-static PyObject *__pyx_pw_5talib_7_ta_lib_579stream_MEDPRICE(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_high = 0;
-  PyArrayObject *__pyx_v_low = 0;
+static PyObject *__pyx_pw_5talib_7_ta_lib_545stream_FLOOR(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_544stream_FLOOR, "stream_FLOOR(ndarray real)\n\nFLOOR(real)\n\nVector Floor (Math Transform)\n\nInputs:\n    real: (any ndarray)\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_545stream_FLOOR = {"stream_FLOOR", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_545stream_FLOOR, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_544stream_FLOOR};
+static PyObject *__pyx_pw_5talib_7_ta_lib_545stream_FLOOR(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_real = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_MEDPRICE (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_FLOOR (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,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);
-        CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 3151, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3151, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_MEDPRICE", 1, 2, 2, 1); __PYX_ERR(3, 3745, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_MEDPRICE") < 0)) __PYX_ERR(3, 3745, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_FLOOR", 0) < (0)) __PYX_ERR(5, 3151, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_FLOOR", 1, 1, 1, i); __PYX_ERR(5, 3151, __pyx_L3_error) }
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
+    } else if (unlikely(__pyx_nargs != 1)) {
       goto __pyx_L5_argtuple_error;
     } else {
-      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3151, __pyx_L3_error)
     }
-    __pyx_v_high = ((PyArrayObject *)values[0]);
-    __pyx_v_low = ((PyArrayObject *)values[1]);
+    __pyx_v_real = ((PyArrayObject *)values[0]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_MEDPRICE", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 3745, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_FLOOR", 1, 1, 1, __pyx_nargs); __PYX_ERR(5, 3151, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_MEDPRICE", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_FLOOR", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 3745, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 3745, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_578stream_MEDPRICE(__pyx_self, __pyx_v_high, __pyx_v_low);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 3153, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_544stream_FLOOR(__pyx_self, __pyx_v_real);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_578stream_MEDPRICE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_544stream_FLOOR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
-  double *__pyx_v_high_data;
-  double *__pyx_v_low_data;
+  double *__pyx_v_real_data;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
   double __pyx_v_outreal;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  npy_intp __pyx_t_2;
-  __Pyx_RefNannySetupContext("stream_MEDPRICE", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_high);
-  __Pyx_INCREF((PyObject *)__pyx_v_low);
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3763, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_v_high_data = ((double *)__pyx_v_high->data);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_FLOOR", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3765, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3170, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_low_data = ((double *)__pyx_v_low->data);
+  __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real));
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_high, __pyx_v_low); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(3, 3767, __pyx_L1_error)
-  __pyx_v_length = __pyx_t_2;
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
   __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
 
-  __pyx_v_retCode = TA_MEDPRICE((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_high_data, __pyx_v_low_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
+  __pyx_v_retCode = TA_FLOOR((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_MEDPRICE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3770, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_FLOOR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3175, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3771, __pyx_L1_error)
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3176, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -55638,11 +68913,10 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_578stream_MEDPRICE(CYTHON_UNUSED PyObj
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_MEDPRICE", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_FLOOR", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_high);
-  __Pyx_XDECREF((PyObject *)__pyx_v_low);
+  __Pyx_XDECREF((PyObject *)__pyx_v_real);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -55650,177 +68924,136 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_578stream_MEDPRICE(CYTHON_UNUSED PyObj
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_581stream_MFI(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_580stream_MFI[] = " MFI(high, low, close, volume[, timeperiod=?])\n\n    Money Flow Index (Momentum Indicators)\n\n    Inputs:\n        prices: ['high', 'low', 'close', 'volume']\n    Parameters:\n        timeperiod: 14\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_581stream_MFI = {"stream_MFI", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_581stream_MFI, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_580stream_MFI};
-static PyObject *__pyx_pw_5talib_7_ta_lib_581stream_MFI(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_high = 0;
-  PyArrayObject *__pyx_v_low = 0;
-  PyArrayObject *__pyx_v_close = 0;
-  PyArrayObject *__pyx_v_volume = 0;
-  int __pyx_v_timeperiod;
+static PyObject *__pyx_pw_5talib_7_ta_lib_547stream_HT_DCPERIOD(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_546stream_HT_DCPERIOD, "stream_HT_DCPERIOD(ndarray real)\n\nHT_DCPERIOD(real)\n\nHilbert Transform - Dominant Cycle Period (Cycle Indicators)\n\nInputs:\n    real: (any ndarray)\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_547stream_HT_DCPERIOD = {"stream_HT_DCPERIOD", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_547stream_HT_DCPERIOD, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_546stream_HT_DCPERIOD};
+static PyObject *__pyx_pw_5talib_7_ta_lib_547stream_HT_DCPERIOD(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_real = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_MFI (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_HT_DCPERIOD (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,&__pyx_n_s_volume,&__pyx_n_s_timeperiod,0};
-    PyObject* values[5] = {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  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
-        CYTHON_FALLTHROUGH;
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 3178, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3178, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_MFI", 0, 4, 5, 1); __PYX_ERR(3, 3775, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_MFI", 0, 4, 5, 2); __PYX_ERR(3, 3775, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_volume)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_MFI", 0, 4, 5, 3); __PYX_ERR(3, 3775, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  4:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod);
-          if (value) { values[4] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_MFI") < 0)) __PYX_ERR(3, 3775, __pyx_L3_error)
-      }
-    } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
-        CYTHON_FALLTHROUGH;
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-        break;
-        default: goto __pyx_L5_argtuple_error;
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_HT_DCPERIOD", 0) < (0)) __PYX_ERR(5, 3178, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_HT_DCPERIOD", 1, 1, 1, i); __PYX_ERR(5, 3178, __pyx_L3_error) }
       }
-    }
-    __pyx_v_high = ((PyArrayObject *)values[0]);
-    __pyx_v_low = ((PyArrayObject *)values[1]);
-    __pyx_v_close = ((PyArrayObject *)values[2]);
-    __pyx_v_volume = ((PyArrayObject *)values[3]);
-    if (values[4]) {
-      __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[4]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3775, __pyx_L3_error)
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
     } else {
-      __pyx_v_timeperiod = ((int)-2147483648);
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3178, __pyx_L3_error)
     }
+    __pyx_v_real = ((PyArrayObject *)values[0]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_MFI", 0, 4, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 3775, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_HT_DCPERIOD", 1, 1, 1, __pyx_nargs); __PYX_ERR(5, 3178, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_MFI", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_HT_DCPERIOD", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 3775, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 3775, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 3775, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_volume), __pyx_ptype_5numpy_ndarray, 0, "volume", 0))) __PYX_ERR(3, 3775, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_580stream_MFI(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_volume, __pyx_v_timeperiod);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 3180, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_546stream_HT_DCPERIOD(__pyx_self, __pyx_v_real);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_580stream_MFI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, PyArrayObject *__pyx_v_volume, int __pyx_v_timeperiod) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_546stream_HT_DCPERIOD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
-  double *__pyx_v_high_data;
-  double *__pyx_v_low_data;
-  double *__pyx_v_close_data;
-  double *__pyx_v_volume_data;
+  double *__pyx_v_real_data;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
   double __pyx_v_outreal;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  npy_intp __pyx_t_2;
-  __Pyx_RefNannySetupContext("stream_MFI", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_high);
-  __Pyx_INCREF((PyObject *)__pyx_v_low);
-  __Pyx_INCREF((PyObject *)__pyx_v_close);
-  __Pyx_INCREF((PyObject *)__pyx_v_volume);
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3797, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_v_high_data = ((double *)__pyx_v_high->data);
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3799, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_v_low_data = ((double *)__pyx_v_low->data);
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3801, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_v_close_data = ((double *)__pyx_v_close->data);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_HT_DCPERIOD", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_volume)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3803, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3197, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_volume, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_volume_data = ((double *)__pyx_v_volume->data);
+  __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real));
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_volume); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(3, 3805, __pyx_L1_error)
-  __pyx_v_length = __pyx_t_2;
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
   __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
 
-  __pyx_v_retCode = TA_MFI((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, __pyx_v_volume_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
+  __pyx_v_retCode = TA_HT_DCPERIOD((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_MFI, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3808, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_HT_DCPERIOD, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3202, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3809, __pyx_L1_error)
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3203, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -55830,13 +69063,10 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_580stream_MFI(CYTHON_UNUSED PyObject *
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_MFI", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_HT_DCPERIOD", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_high);
-  __Pyx_XDECREF((PyObject *)__pyx_v_low);
-  __Pyx_XDECREF((PyObject *)__pyx_v_close);
-  __Pyx_XDECREF((PyObject *)__pyx_v_volume);
+  __Pyx_XDECREF((PyObject *)__pyx_v_real);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -55844,81 +69074,102 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_580stream_MFI(CYTHON_UNUSED PyObject *
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_583stream_MIDPOINT(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_582stream_MIDPOINT[] = " MIDPOINT(real[, timeperiod=?])\n\n    MidPoint over period (Overlap Studies)\n\n    Inputs:\n        real: (any ndarray)\n    Parameters:\n        timeperiod: 14\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_583stream_MIDPOINT = {"stream_MIDPOINT", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_583stream_MIDPOINT, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_582stream_MIDPOINT};
-static PyObject *__pyx_pw_5talib_7_ta_lib_583stream_MIDPOINT(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_549stream_HT_DCPHASE(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_548stream_HT_DCPHASE, "stream_HT_DCPHASE(ndarray real)\n\nHT_DCPHASE(real)\n\nHilbert Transform - Dominant Cycle Phase (Cycle Indicators)\n\nInputs:\n    real: (any ndarray)\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_549stream_HT_DCPHASE = {"stream_HT_DCPHASE", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_549stream_HT_DCPHASE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_548stream_HT_DCPHASE};
+static PyObject *__pyx_pw_5talib_7_ta_lib_549stream_HT_DCPHASE(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_real = 0;
-  int __pyx_v_timeperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_MIDPOINT (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_HT_DCPHASE (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,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);
-        CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 3205, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3205, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod);
-          if (value) { values[1] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_MIDPOINT") < 0)) __PYX_ERR(3, 3813, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_HT_DCPHASE", 0) < (0)) __PYX_ERR(5, 3205, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_HT_DCPHASE", 1, 1, 1, i); __PYX_ERR(5, 3205, __pyx_L3_error) }
       }
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-        break;
-        default: goto __pyx_L5_argtuple_error;
-      }
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3205, __pyx_L3_error)
     }
     __pyx_v_real = ((PyArrayObject *)values[0]);
-    if (values[1]) {
-      __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3813, __pyx_L3_error)
-    } else {
-      __pyx_v_timeperiod = ((int)-2147483648);
-    }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_MIDPOINT", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 3813, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_HT_DCPHASE", 1, 1, 1, __pyx_nargs); __PYX_ERR(5, 3205, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_MIDPOINT", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_HT_DCPHASE", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 3813, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_582stream_MIDPOINT(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 3207, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_548stream_HT_DCPHASE(__pyx_self, __pyx_v_real);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_582stream_MIDPOINT(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_548stream_HT_DCPHASE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
   double *__pyx_v_real_data;
@@ -55928,28 +69179,31 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_582stream_MIDPOINT(CYTHON_UNUSED PyObj
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  __Pyx_RefNannySetupContext("stream_MIDPOINT", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_HT_DCPHASE", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3832, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3224, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_real_data = ((double *)__pyx_v_real->data);
+  __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real));
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
   __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
 
-  __pyx_v_retCode = TA_MIDPOINT((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
+  __pyx_v_retCode = TA_HT_DCPHASE((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_MIDPOINT, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3837, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_HT_DCPHASE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3229, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3838, __pyx_L1_error)
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3230, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -55959,7 +69213,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_582stream_MIDPOINT(CYTHON_UNUSED PyObj
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_MIDPOINT", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_HT_DCPHASE", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_real);
@@ -55970,149 +69224,166 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_582stream_MIDPOINT(CYTHON_UNUSED PyObj
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_585stream_MIDPRICE(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_584stream_MIDPRICE[] = " MIDPRICE(high, low[, timeperiod=?])\n\n    Midpoint Price over period (Overlap Studies)\n\n    Inputs:\n        prices: ['high', 'low']\n    Parameters:\n        timeperiod: 14\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_585stream_MIDPRICE = {"stream_MIDPRICE", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_585stream_MIDPRICE, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_584stream_MIDPRICE};
-static PyObject *__pyx_pw_5talib_7_ta_lib_585stream_MIDPRICE(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_high = 0;
-  PyArrayObject *__pyx_v_low = 0;
-  int __pyx_v_timeperiod;
+static PyObject *__pyx_pw_5talib_7_ta_lib_551stream_HT_PHASOR(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_550stream_HT_PHASOR, "stream_HT_PHASOR(ndarray real)\n\nHT_PHASOR(real)\n\nHilbert Transform - Phasor Components (Cycle Indicators)\n\nInputs:\n    real: (any ndarray)\nOutputs:\n    inphase\n    quadrature");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_551stream_HT_PHASOR = {"stream_HT_PHASOR", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_551stream_HT_PHASOR, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_550stream_HT_PHASOR};
+static PyObject *__pyx_pw_5talib_7_ta_lib_551stream_HT_PHASOR(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_real = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_MIDPRICE (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_HT_PHASOR (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_timeperiod,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);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 3232, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3232, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_MIDPRICE", 0, 2, 3, 1); __PYX_ERR(3, 3842, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod);
-          if (value) { values[2] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_MIDPRICE") < 0)) __PYX_ERR(3, 3842, __pyx_L3_error)
-      }
-    } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-        break;
-        default: goto __pyx_L5_argtuple_error;
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_HT_PHASOR", 0) < (0)) __PYX_ERR(5, 3232, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_HT_PHASOR", 1, 1, 1, i); __PYX_ERR(5, 3232, __pyx_L3_error) }
       }
-    }
-    __pyx_v_high = ((PyArrayObject *)values[0]);
-    __pyx_v_low = ((PyArrayObject *)values[1]);
-    if (values[2]) {
-      __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3842, __pyx_L3_error)
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
     } else {
-      __pyx_v_timeperiod = ((int)-2147483648);
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3232, __pyx_L3_error)
     }
+    __pyx_v_real = ((PyArrayObject *)values[0]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_MIDPRICE", 0, 2, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 3842, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_HT_PHASOR", 1, 1, 1, __pyx_nargs); __PYX_ERR(5, 3232, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_MIDPRICE", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_HT_PHASOR", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 3842, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 3842, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_584stream_MIDPRICE(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_timeperiod);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 3234, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_550stream_HT_PHASOR(__pyx_self, __pyx_v_real);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_584stream_MIDPRICE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, int __pyx_v_timeperiod) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_550stream_HT_PHASOR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
-  double *__pyx_v_high_data;
-  double *__pyx_v_low_data;
+  double *__pyx_v_real_data;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  double __pyx_v_outreal;
+  double __pyx_v_outinphase;
+  double __pyx_v_outquadrature;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  npy_intp __pyx_t_2;
-  __Pyx_RefNannySetupContext("stream_MIDPRICE", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_high);
-  __Pyx_INCREF((PyObject *)__pyx_v_low);
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_HT_PHASOR", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3862, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3253, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_high_data = ((double *)__pyx_v_high->data);
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3864, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
+  __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real));
 
-  __pyx_v_low_data = ((double *)__pyx_v_low->data);
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_high, __pyx_v_low); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(3, 3866, __pyx_L1_error)
-  __pyx_v_length = __pyx_t_2;
+  __pyx_v_outinphase = __pyx_v_5talib_7_ta_lib_NaN;
 
-  __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
+  __pyx_v_outquadrature = __pyx_v_5talib_7_ta_lib_NaN;
 
-  __pyx_v_retCode = TA_MIDPRICE((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_high_data, __pyx_v_low_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
+  __pyx_v_retCode = TA_HT_PHASOR((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinphase), (&__pyx_v_outquadrature));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_MIDPRICE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3869, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_HT_PHASOR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3259, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3870, __pyx_L1_error)
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outinphase); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3260, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_r = __pyx_t_1;
+  __pyx_t_2 = PyFloat_FromDouble(__pyx_v_outquadrature); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 3260, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 3260, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_GIVEREF(__pyx_t_1);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1) != (0)) __PYX_ERR(5, 3260, __pyx_L1_error);
+  __Pyx_GIVEREF(__pyx_t_2);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_2) != (0)) __PYX_ERR(5, 3260, __pyx_L1_error);
   __pyx_t_1 = 0;
+  __pyx_t_2 = 0;
+  __pyx_r = __pyx_t_3;
+  __pyx_t_3 = 0;
   goto __pyx_L0;
 
 
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_MIDPRICE", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("talib._ta_lib.stream_HT_PHASOR", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_high);
-  __Pyx_XDECREF((PyObject *)__pyx_v_low);
+  __Pyx_XDECREF((PyObject *)__pyx_v_real);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -56120,122 +69391,163 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_584stream_MIDPRICE(CYTHON_UNUSED PyObj
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_587stream_MIN(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_586stream_MIN[] = " MIN(real[, timeperiod=?])\n\n    Lowest value over a specified period (Math Operators)\n\n    Inputs:\n        real: (any ndarray)\n    Parameters:\n        timeperiod: 30\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_587stream_MIN = {"stream_MIN", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_587stream_MIN, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_586stream_MIN};
-static PyObject *__pyx_pw_5talib_7_ta_lib_587stream_MIN(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_553stream_HT_SINE(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_552stream_HT_SINE, "stream_HT_SINE(ndarray real)\n\nHT_SINE(real)\n\nHilbert Transform - SineWave (Cycle Indicators)\n\nInputs:\n    real: (any ndarray)\nOutputs:\n    sine\n    leadsine");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_553stream_HT_SINE = {"stream_HT_SINE", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_553stream_HT_SINE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_552stream_HT_SINE};
+static PyObject *__pyx_pw_5talib_7_ta_lib_553stream_HT_SINE(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_real = 0;
-  int __pyx_v_timeperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_MIN (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_HT_SINE (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,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);
-        CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 3262, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3262, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod);
-          if (value) { values[1] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_MIN") < 0)) __PYX_ERR(3, 3874, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_HT_SINE", 0) < (0)) __PYX_ERR(5, 3262, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_HT_SINE", 1, 1, 1, i); __PYX_ERR(5, 3262, __pyx_L3_error) }
       }
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-        break;
-        default: goto __pyx_L5_argtuple_error;
-      }
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3262, __pyx_L3_error)
     }
     __pyx_v_real = ((PyArrayObject *)values[0]);
-    if (values[1]) {
-      __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3874, __pyx_L3_error)
-    } else {
-      __pyx_v_timeperiod = ((int)-2147483648);
-    }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_MIN", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 3874, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_HT_SINE", 1, 1, 1, __pyx_nargs); __PYX_ERR(5, 3262, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_MIN", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_HT_SINE", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 3874, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_586stream_MIN(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 3264, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_552stream_HT_SINE(__pyx_self, __pyx_v_real);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_586stream_MIN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_552stream_HT_SINE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
   double *__pyx_v_real_data;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  double __pyx_v_outreal;
+  double __pyx_v_outsine;
+  double __pyx_v_outleadsine;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  __Pyx_RefNannySetupContext("stream_MIN", 0);
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_HT_SINE", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3893, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3283, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_real_data = ((double *)__pyx_v_real->data);
+  __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real));
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
-  __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
+  __pyx_v_outsine = __pyx_v_5talib_7_ta_lib_NaN;
 
-  __pyx_v_retCode = TA_MIN((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
+  __pyx_v_outleadsine = __pyx_v_5talib_7_ta_lib_NaN;
+
+  __pyx_v_retCode = TA_HT_SINE((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outsine), (&__pyx_v_outleadsine));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_MIN, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3898, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_HT_SINE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3289, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3899, __pyx_L1_error)
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outsine); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3290, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_r = __pyx_t_1;
+  __pyx_t_2 = PyFloat_FromDouble(__pyx_v_outleadsine); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 3290, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 3290, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_GIVEREF(__pyx_t_1);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1) != (0)) __PYX_ERR(5, 3290, __pyx_L1_error);
+  __Pyx_GIVEREF(__pyx_t_2);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_2) != (0)) __PYX_ERR(5, 3290, __pyx_L1_error);
   __pyx_t_1 = 0;
+  __pyx_t_2 = 0;
+  __pyx_r = __pyx_t_3;
+  __pyx_t_3 = 0;
   goto __pyx_L0;
 
 
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_MIN", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("talib._ta_lib.stream_HT_SINE", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_real);
@@ -56246,112 +69558,136 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_586stream_MIN(CYTHON_UNUSED PyObject *
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_589stream_MININDEX(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_588stream_MININDEX[] = " MININDEX(real[, timeperiod=?])\n\n    Index of lowest value over a specified period (Math Operators)\n\n    Inputs:\n        real: (any ndarray)\n    Parameters:\n        timeperiod: 30\n    Outputs:\n        integer (values are -100, 0 or 100)\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_589stream_MININDEX = {"stream_MININDEX", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_589stream_MININDEX, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_588stream_MININDEX};
-static PyObject *__pyx_pw_5talib_7_ta_lib_589stream_MININDEX(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_555stream_HT_TRENDLINE(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_554stream_HT_TRENDLINE, "stream_HT_TRENDLINE(ndarray real)\n\nHT_TRENDLINE(real)\n\nHilbert Transform - Instantaneous Trendline (Overlap Studies)\n\nInputs:\n    real: (any ndarray)\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_555stream_HT_TRENDLINE = {"stream_HT_TRENDLINE", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_555stream_HT_TRENDLINE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_554stream_HT_TRENDLINE};
+static PyObject *__pyx_pw_5talib_7_ta_lib_555stream_HT_TRENDLINE(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_real = 0;
-  int __pyx_v_timeperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_MININDEX (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_HT_TRENDLINE (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,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);
-        CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 3292, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3292, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod);
-          if (value) { values[1] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_MININDEX") < 0)) __PYX_ERR(3, 3903, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_HT_TRENDLINE", 0) < (0)) __PYX_ERR(5, 3292, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_HT_TRENDLINE", 1, 1, 1, i); __PYX_ERR(5, 3292, __pyx_L3_error) }
       }
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-        break;
-        default: goto __pyx_L5_argtuple_error;
-      }
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3292, __pyx_L3_error)
     }
     __pyx_v_real = ((PyArrayObject *)values[0]);
-    if (values[1]) {
-      __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3903, __pyx_L3_error)
-    } else {
-      __pyx_v_timeperiod = ((int)-2147483648);
-    }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_MININDEX", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 3903, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_HT_TRENDLINE", 1, 1, 1, __pyx_nargs); __PYX_ERR(5, 3292, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_MININDEX", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_HT_TRENDLINE", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 3903, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_588stream_MININDEX(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 3294, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_554stream_HT_TRENDLINE(__pyx_self, __pyx_v_real);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_588stream_MININDEX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_554stream_HT_TRENDLINE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
   double *__pyx_v_real_data;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  int __pyx_v_outinteger;
+  double __pyx_v_outreal;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  __Pyx_RefNannySetupContext("stream_MININDEX", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_HT_TRENDLINE", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3922, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3311, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_real_data = ((double *)__pyx_v_real->data);
+  __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real));
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
-  __pyx_v_outinteger = 0;
+  __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
 
-  __pyx_v_retCode = TA_MININDEX((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
+  __pyx_v_retCode = TA_HT_TRENDLINE((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_MININDEX, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3927, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_HT_TRENDLINE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3316, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3928, __pyx_L1_error)
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3317, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -56361,7 +69697,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_588stream_MININDEX(CYTHON_UNUSED PyObj
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_MININDEX", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_HT_TRENDLINE", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_real);
@@ -56372,139 +69708,146 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_588stream_MININDEX(CYTHON_UNUSED PyObj
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_591stream_MINMAX(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_590stream_MINMAX[] = " MINMAX(real[, timeperiod=?])\n\n    Lowest and highest values over a specified period (Math Operators)\n\n    Inputs:\n        real: (any ndarray)\n    Parameters:\n        timeperiod: 30\n    Outputs:\n        min\n        max\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_591stream_MINMAX = {"stream_MINMAX", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_591stream_MINMAX, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_590stream_MINMAX};
-static PyObject *__pyx_pw_5talib_7_ta_lib_591stream_MINMAX(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_557stream_HT_TRENDMODE(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_556stream_HT_TRENDMODE, "stream_HT_TRENDMODE(ndarray real)\n\nHT_TRENDMODE(real)\n\nHilbert Transform - Trend vs Cycle Mode (Cycle Indicators)\n\nInputs:\n    real: (any ndarray)\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_557stream_HT_TRENDMODE = {"stream_HT_TRENDMODE", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_557stream_HT_TRENDMODE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_556stream_HT_TRENDMODE};
+static PyObject *__pyx_pw_5talib_7_ta_lib_557stream_HT_TRENDMODE(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_real = 0;
-  int __pyx_v_timeperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_MINMAX (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_HT_TRENDMODE (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,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);
-        CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 3319, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3319, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod);
-          if (value) { values[1] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_MINMAX") < 0)) __PYX_ERR(3, 3932, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_HT_TRENDMODE", 0) < (0)) __PYX_ERR(5, 3319, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_HT_TRENDMODE", 1, 1, 1, i); __PYX_ERR(5, 3319, __pyx_L3_error) }
       }
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-        break;
-        default: goto __pyx_L5_argtuple_error;
-      }
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3319, __pyx_L3_error)
     }
     __pyx_v_real = ((PyArrayObject *)values[0]);
-    if (values[1]) {
-      __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3932, __pyx_L3_error)
-    } else {
-      __pyx_v_timeperiod = ((int)-2147483648);
-    }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_MINMAX", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 3932, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_HT_TRENDMODE", 1, 1, 1, __pyx_nargs); __PYX_ERR(5, 3319, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_MINMAX", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_HT_TRENDMODE", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 3932, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_590stream_MINMAX(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 3321, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_556stream_HT_TRENDMODE(__pyx_self, __pyx_v_real);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_590stream_MINMAX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_556stream_HT_TRENDMODE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
   double *__pyx_v_real_data;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  double __pyx_v_outmin;
-  double __pyx_v_outmax;
+  int __pyx_v_outinteger;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  PyObject *__pyx_t_2 = NULL;
-  PyObject *__pyx_t_3 = NULL;
-  __Pyx_RefNannySetupContext("stream_MINMAX", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_HT_TRENDMODE", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3953, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3338, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_real_data = ((double *)__pyx_v_real->data);
+  __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real));
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
-  __pyx_v_outmin = __pyx_v_5talib_7_ta_lib_NaN;
-
-  __pyx_v_outmax = __pyx_v_5talib_7_ta_lib_NaN;
+  __pyx_v_outinteger = 0;
 
-  __pyx_v_retCode = TA_MINMAX((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outmin), (&__pyx_v_outmax));
+  __pyx_v_retCode = TA_HT_TRENDMODE((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_MINMAX, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3959, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_HT_TRENDMODE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3343, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outmin); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3960, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3344, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = PyFloat_FromDouble(__pyx_v_outmax); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 3960, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3960, __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_r = __pyx_t_1;
   __pyx_t_1 = 0;
-  __pyx_t_2 = 0;
-  __pyx_r = __pyx_t_3;
-  __pyx_t_3 = 0;
   goto __pyx_L0;
 
 
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_XDECREF(__pyx_t_2);
-  __Pyx_XDECREF(__pyx_t_3);
-  __Pyx_AddTraceback("talib._ta_lib.stream_MINMAX", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_HT_TRENDMODE", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_real);
@@ -56515,142 +69858,187 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_590stream_MINMAX(CYTHON_UNUSED PyObjec
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_593stream_MINMAXINDEX(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_592stream_MINMAXINDEX[] = " MINMAXINDEX(real[, timeperiod=?])\n\n    Indexes of lowest and highest values over a specified period (Math Operators)\n\n    Inputs:\n        real: (any ndarray)\n    Parameters:\n        timeperiod: 30\n    Outputs:\n        minidx\n        maxidx\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_593stream_MINMAXINDEX = {"stream_MINMAXINDEX", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_593stream_MINMAXINDEX, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_592stream_MINMAXINDEX};
-static PyObject *__pyx_pw_5talib_7_ta_lib_593stream_MINMAXINDEX(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_real = 0;
+static PyObject *__pyx_pw_5talib_7_ta_lib_559stream_IMI(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_558stream_IMI, "stream_IMI(ndarray open, ndarray close, int timeperiod=-0x80000000)\n\nIMI(open, close[, timeperiod=?])\n\nIntraday Momentum Index (Momentum Indicators)\n\nInputs:\n    prices: ['open', 'close']\nParameters:\n    timeperiod: 14\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_559stream_IMI = {"stream_IMI", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_559stream_IMI, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_558stream_IMI};
+static PyObject *__pyx_pw_5talib_7_ta_lib_559stream_IMI(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_open = 0;
+  PyArrayObject *__pyx_v_close = 0;
   int __pyx_v_timeperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[3] = {0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_MINMAXINDEX (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_IMI (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,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);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_open,&__pyx_mstate_global->__pyx_n_u_close,&__pyx_mstate_global->__pyx_n_u_timeperiod,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 3346, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 3346, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 3346, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3346, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod);
-          if (value) { values[1] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_MINMAXINDEX") < 0)) __PYX_ERR(3, 3964, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_IMI", 0) < (0)) __PYX_ERR(5, 3346, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_IMI", 0, 2, 3, i); __PYX_ERR(5, 3346, __pyx_L3_error) }
       }
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      switch (__pyx_nargs) {
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 3346, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 3346, __pyx_L3_error)
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3346, __pyx_L3_error)
         break;
         default: goto __pyx_L5_argtuple_error;
       }
     }
-    __pyx_v_real = ((PyArrayObject *)values[0]);
-    if (values[1]) {
-      __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3964, __pyx_L3_error)
+    __pyx_v_open = ((PyArrayObject *)values[0]);
+    __pyx_v_close = ((PyArrayObject *)values[1]);
+    if (values[2]) {
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[2]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 3348, __pyx_L3_error)
     } else {
-      __pyx_v_timeperiod = ((int)-2147483648);
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
     }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_MINMAXINDEX", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 3964, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_IMI", 0, 2, 3, __pyx_nargs); __PYX_ERR(5, 3346, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_MINMAXINDEX", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_IMI", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 3964, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_592stream_MINMAXINDEX(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_open), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "open", 0))) __PYX_ERR(5, 3348, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 3348, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_558stream_IMI(__pyx_self, __pyx_v_open, __pyx_v_close, __pyx_v_timeperiod);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_592stream_MINMAXINDEX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_558stream_IMI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_open, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
-  double *__pyx_v_real_data;
+  double *__pyx_v_open_data;
+  double *__pyx_v_close_data;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  int __pyx_v_outminidx;
-  int __pyx_v_outmaxidx;
+  double __pyx_v_outreal;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  PyObject *__pyx_t_2 = NULL;
-  PyObject *__pyx_t_3 = NULL;
-  __Pyx_RefNannySetupContext("stream_MINMAXINDEX", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_real);
+  npy_intp __pyx_t_2;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_IMI", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_open);
+  __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3985, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3368, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_open, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_real_data = ((double *)__pyx_v_real->data);
+  __pyx_v_open_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open));
+
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3370, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close));
 
-  __pyx_v_outminidx = 0;
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_open, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 3372, __pyx_L1_error)
+  __pyx_v_length = __pyx_t_2;
 
-  __pyx_v_outmaxidx = 0;
+  __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
 
-  __pyx_v_retCode = TA_MINMAXINDEX((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outminidx), (&__pyx_v_outmaxidx));
+  __pyx_v_retCode = TA_IMI((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_open_data, __pyx_v_close_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_MINMAXINDEX, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3991, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_IMI, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3375, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_outminidx); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 3992, __pyx_L1_error)
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3376, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_outmaxidx); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 3992, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 3992, __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_r = __pyx_t_1;
   __pyx_t_1 = 0;
-  __pyx_t_2 = 0;
-  __pyx_r = __pyx_t_3;
-  __pyx_t_3 = 0;
   goto __pyx_L0;
 
 
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_XDECREF(__pyx_t_2);
-  __Pyx_XDECREF(__pyx_t_3);
-  __Pyx_AddTraceback("talib._ta_lib.stream_MINMAXINDEX", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_IMI", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_real);
+  __Pyx_XDECREF((PyObject *)__pyx_v_open);
+  __Pyx_XDECREF((PyObject *)__pyx_v_close);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -56658,156 +70046,153 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_592stream_MINMAXINDEX(CYTHON_UNUSED Py
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_595stream_MINUS_DI(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_594stream_MINUS_DI[] = " MINUS_DI(high, low, close[, timeperiod=?])\n\n    Minus Directional Indicator (Momentum Indicators)\n\n    Inputs:\n        prices: ['high', 'low', 'close']\n    Parameters:\n        timeperiod: 14\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_595stream_MINUS_DI = {"stream_MINUS_DI", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_595stream_MINUS_DI, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_594stream_MINUS_DI};
-static PyObject *__pyx_pw_5talib_7_ta_lib_595stream_MINUS_DI(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_high = 0;
-  PyArrayObject *__pyx_v_low = 0;
-  PyArrayObject *__pyx_v_close = 0;
+static PyObject *__pyx_pw_5talib_7_ta_lib_561stream_KAMA(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_560stream_KAMA, "stream_KAMA(ndarray real, int timeperiod=-0x80000000)\n\nKAMA(real[, timeperiod=?])\n\nKaufman Adaptive Moving Average (Overlap Studies)\n\nInputs:\n    real: (any ndarray)\nParameters:\n    timeperiod: 30\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_561stream_KAMA = {"stream_KAMA", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_561stream_KAMA, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_560stream_KAMA};
+static PyObject *__pyx_pw_5talib_7_ta_lib_561stream_KAMA(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_real = 0;
   int __pyx_v_timeperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_MINUS_DI (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_KAMA (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,&__pyx_n_s_timeperiod,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 3378, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 3378, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3378, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_MINUS_DI", 0, 3, 4, 1); __PYX_ERR(3, 3996, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_MINUS_DI", 0, 3, 4, 2); __PYX_ERR(3, 3996, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod);
-          if (value) { values[3] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_MINUS_DI") < 0)) __PYX_ERR(3, 3996, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_KAMA", 0) < (0)) __PYX_ERR(5, 3378, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_KAMA", 0, 1, 2, i); __PYX_ERR(5, 3378, __pyx_L3_error) }
       }
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 3378, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3378, __pyx_L3_error)
         break;
         default: goto __pyx_L5_argtuple_error;
       }
     }
-    __pyx_v_high = ((PyArrayObject *)values[0]);
-    __pyx_v_low = ((PyArrayObject *)values[1]);
-    __pyx_v_close = ((PyArrayObject *)values[2]);
-    if (values[3]) {
-      __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[3]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 3996, __pyx_L3_error)
+    __pyx_v_real = ((PyArrayObject *)values[0]);
+    if (values[1]) {
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 3380, __pyx_L3_error)
     } else {
-      __pyx_v_timeperiod = ((int)-2147483648);
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
     }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_MINUS_DI", 0, 3, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 3996, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_KAMA", 0, 1, 2, __pyx_nargs); __PYX_ERR(5, 3378, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_MINUS_DI", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_KAMA", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 3996, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 3996, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 3996, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_594stream_MINUS_DI(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_timeperiod);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 3380, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_560stream_KAMA(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_594stream_MINUS_DI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_560stream_KAMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
-  double *__pyx_v_high_data;
-  double *__pyx_v_low_data;
-  double *__pyx_v_close_data;
+  double *__pyx_v_real_data;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
   double __pyx_v_outreal;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  npy_intp __pyx_t_2;
-  __Pyx_RefNannySetupContext("stream_MINUS_DI", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_high);
-  __Pyx_INCREF((PyObject *)__pyx_v_low);
-  __Pyx_INCREF((PyObject *)__pyx_v_close);
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4017, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_v_high_data = ((double *)__pyx_v_high->data);
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4019, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_v_low_data = ((double *)__pyx_v_low->data);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_KAMA", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4021, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3399, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_close_data = ((double *)__pyx_v_close->data);
+  __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real));
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(3, 4023, __pyx_L1_error)
-  __pyx_v_length = __pyx_t_2;
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
   __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
 
-  __pyx_v_retCode = TA_MINUS_DI((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
+  __pyx_v_retCode = TA_KAMA((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_MINUS_DI, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4026, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_KAMA, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3404, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4027, __pyx_L1_error)
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3405, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -56817,12 +70202,10 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_594stream_MINUS_DI(CYTHON_UNUSED PyObj
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_MINUS_DI", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_KAMA", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_high);
-  __Pyx_XDECREF((PyObject *)__pyx_v_low);
-  __Pyx_XDECREF((PyObject *)__pyx_v_close);
+  __Pyx_XDECREF((PyObject *)__pyx_v_real);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -56830,135 +70213,153 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_594stream_MINUS_DI(CYTHON_UNUSED PyObj
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_597stream_MINUS_DM(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_596stream_MINUS_DM[] = " MINUS_DM(high, low[, timeperiod=?])\n\n    Minus Directional Movement (Momentum Indicators)\n\n    Inputs:\n        prices: ['high', 'low']\n    Parameters:\n        timeperiod: 14\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_597stream_MINUS_DM = {"stream_MINUS_DM", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_597stream_MINUS_DM, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_596stream_MINUS_DM};
-static PyObject *__pyx_pw_5talib_7_ta_lib_597stream_MINUS_DM(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_high = 0;
-  PyArrayObject *__pyx_v_low = 0;
+static PyObject *__pyx_pw_5talib_7_ta_lib_563stream_LINEARREG(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_562stream_LINEARREG, "stream_LINEARREG(ndarray real, int timeperiod=-0x80000000)\n\nLINEARREG(real[, timeperiod=?])\n\nLinear Regression (Statistic Functions)\n\nInputs:\n    real: (any ndarray)\nParameters:\n    timeperiod: 14\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_563stream_LINEARREG = {"stream_LINEARREG", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_563stream_LINEARREG, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_562stream_LINEARREG};
+static PyObject *__pyx_pw_5talib_7_ta_lib_563stream_LINEARREG(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_real = 0;
   int __pyx_v_timeperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_MINUS_DM (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_LINEARREG (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_timeperiod,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);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 3407, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 3407, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3407, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_MINUS_DM", 0, 2, 3, 1); __PYX_ERR(3, 4031, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod);
-          if (value) { values[2] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_MINUS_DM") < 0)) __PYX_ERR(3, 4031, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_LINEARREG", 0) < (0)) __PYX_ERR(5, 3407, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_LINEARREG", 0, 1, 2, i); __PYX_ERR(5, 3407, __pyx_L3_error) }
       }
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 3407, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3407, __pyx_L3_error)
         break;
         default: goto __pyx_L5_argtuple_error;
       }
     }
-    __pyx_v_high = ((PyArrayObject *)values[0]);
-    __pyx_v_low = ((PyArrayObject *)values[1]);
-    if (values[2]) {
-      __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4031, __pyx_L3_error)
+    __pyx_v_real = ((PyArrayObject *)values[0]);
+    if (values[1]) {
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 3409, __pyx_L3_error)
     } else {
-      __pyx_v_timeperiod = ((int)-2147483648);
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
     }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_MINUS_DM", 0, 2, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 4031, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_LINEARREG", 0, 1, 2, __pyx_nargs); __PYX_ERR(5, 3407, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_MINUS_DM", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_LINEARREG", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 4031, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 4031, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_596stream_MINUS_DM(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_timeperiod);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 3409, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_562stream_LINEARREG(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_596stream_MINUS_DM(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, int __pyx_v_timeperiod) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_562stream_LINEARREG(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
-  double *__pyx_v_high_data;
-  double *__pyx_v_low_data;
+  double *__pyx_v_real_data;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
   double __pyx_v_outreal;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  npy_intp __pyx_t_2;
-  __Pyx_RefNannySetupContext("stream_MINUS_DM", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_high);
-  __Pyx_INCREF((PyObject *)__pyx_v_low);
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4051, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_v_high_data = ((double *)__pyx_v_high->data);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_LINEARREG", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4053, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3428, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_low_data = ((double *)__pyx_v_low->data);
+  __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real));
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_high, __pyx_v_low); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(3, 4055, __pyx_L1_error)
-  __pyx_v_length = __pyx_t_2;
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
   __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
 
-  __pyx_v_retCode = TA_MINUS_DM((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_high_data, __pyx_v_low_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
+  __pyx_v_retCode = TA_LINEARREG((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_MINUS_DM, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4058, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_LINEARREG, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3433, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4059, __pyx_L1_error)
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3434, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -56968,11 +70369,10 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_596stream_MINUS_DM(CYTHON_UNUSED PyObj
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_MINUS_DM", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_LINEARREG", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_high);
-  __Pyx_XDECREF((PyObject *)__pyx_v_low);
+  __Pyx_XDECREF((PyObject *)__pyx_v_real);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -56980,81 +70380,119 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_596stream_MINUS_DM(CYTHON_UNUSED PyObj
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_599stream_MOM(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_598stream_MOM[] = " MOM(real[, timeperiod=?])\n\n    Momentum (Momentum Indicators)\n\n    Inputs:\n        real: (any ndarray)\n    Parameters:\n        timeperiod: 10\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_599stream_MOM = {"stream_MOM", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_599stream_MOM, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_598stream_MOM};
-static PyObject *__pyx_pw_5talib_7_ta_lib_599stream_MOM(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_565stream_LINEARREG_ANGLE(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_564stream_LINEARREG_ANGLE, "stream_LINEARREG_ANGLE(ndarray real, int timeperiod=-0x80000000)\n\nLINEARREG_ANGLE(real[, timeperiod=?])\n\nLinear Regression Angle (Statistic Functions)\n\nInputs:\n    real: (any ndarray)\nParameters:\n    timeperiod: 14\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_565stream_LINEARREG_ANGLE = {"stream_LINEARREG_ANGLE", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_565stream_LINEARREG_ANGLE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_564stream_LINEARREG_ANGLE};
+static PyObject *__pyx_pw_5talib_7_ta_lib_565stream_LINEARREG_ANGLE(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_real = 0;
   int __pyx_v_timeperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_MOM (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_LINEARREG_ANGLE (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,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);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 3436, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 3436, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3436, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod);
-          if (value) { values[1] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_MOM") < 0)) __PYX_ERR(3, 4063, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_LINEARREG_ANGLE", 0) < (0)) __PYX_ERR(5, 3436, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_LINEARREG_ANGLE", 0, 1, 2, i); __PYX_ERR(5, 3436, __pyx_L3_error) }
       }
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 3436, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3436, __pyx_L3_error)
         break;
         default: goto __pyx_L5_argtuple_error;
       }
     }
     __pyx_v_real = ((PyArrayObject *)values[0]);
     if (values[1]) {
-      __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4063, __pyx_L3_error)
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 3438, __pyx_L3_error)
     } else {
-      __pyx_v_timeperiod = ((int)-2147483648);
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
     }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_MOM", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 4063, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_LINEARREG_ANGLE", 0, 1, 2, __pyx_nargs); __PYX_ERR(5, 3436, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_MOM", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_LINEARREG_ANGLE", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 4063, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_598stream_MOM(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 3438, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_564stream_LINEARREG_ANGLE(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_598stream_MOM(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_564stream_LINEARREG_ANGLE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
   double *__pyx_v_real_data;
@@ -57064,28 +70502,31 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_598stream_MOM(CYTHON_UNUSED PyObject *
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  __Pyx_RefNannySetupContext("stream_MOM", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_LINEARREG_ANGLE", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4082, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3457, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_real_data = ((double *)__pyx_v_real->data);
+  __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real));
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
   __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
 
-  __pyx_v_retCode = TA_MOM((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
+  __pyx_v_retCode = TA_LINEARREG_ANGLE((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_MOM, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4087, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_LINEARREG_ANGLE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3462, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4088, __pyx_L1_error)
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3463, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -57095,7 +70536,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_598stream_MOM(CYTHON_UNUSED PyObject *
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_MOM", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_LINEARREG_ANGLE", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_real);
@@ -57106,117 +70547,153 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_598stream_MOM(CYTHON_UNUSED PyObject *
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_601stream_MULT(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_600stream_MULT[] = " MULT(real0, real1)\n\n    Vector Arithmetic Mult (Math Operators)\n\n    Inputs:\n        real0: (any ndarray)\n        real1: (any ndarray)\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_601stream_MULT = {"stream_MULT", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_601stream_MULT, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_600stream_MULT};
-static PyObject *__pyx_pw_5talib_7_ta_lib_601stream_MULT(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_real0 = 0;
-  PyArrayObject *__pyx_v_real1 = 0;
+static PyObject *__pyx_pw_5talib_7_ta_lib_567stream_LINEARREG_INTERCEPT(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_566stream_LINEARREG_INTERCEPT, "stream_LINEARREG_INTERCEPT(ndarray real, int timeperiod=-0x80000000)\n\nLINEARREG_INTERCEPT(real[, timeperiod=?])\n\nLinear Regression Intercept (Statistic Functions)\n\nInputs:\n    real: (any ndarray)\nParameters:\n    timeperiod: 14\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_567stream_LINEARREG_INTERCEPT = {"stream_LINEARREG_INTERCEPT", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_567stream_LINEARREG_INTERCEPT, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_566stream_LINEARREG_INTERCEPT};
+static PyObject *__pyx_pw_5talib_7_ta_lib_567stream_LINEARREG_INTERCEPT(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_real = 0;
+  int __pyx_v_timeperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_MULT (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_LINEARREG_INTERCEPT (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real0,&__pyx_n_s_real1,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);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 3465, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 3465, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3465, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real0)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_LINEARREG_INTERCEPT", 0) < (0)) __PYX_ERR(5, 3465, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_LINEARREG_INTERCEPT", 0, 1, 2, i); __PYX_ERR(5, 3465, __pyx_L3_error) }
+      }
+    } else {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 3465, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real1)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_MULT", 1, 2, 2, 1); __PYX_ERR(3, 4092, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_MULT") < 0)) __PYX_ERR(3, 4092, __pyx_L3_error)
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3465, __pyx_L3_error)
+        break;
+        default: goto __pyx_L5_argtuple_error;
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
-      goto __pyx_L5_argtuple_error;
+    }
+    __pyx_v_real = ((PyArrayObject *)values[0]);
+    if (values[1]) {
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 3467, __pyx_L3_error)
     } else {
-      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
     }
-    __pyx_v_real0 = ((PyArrayObject *)values[0]);
-    __pyx_v_real1 = ((PyArrayObject *)values[1]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_MULT", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 4092, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_LINEARREG_INTERCEPT", 0, 1, 2, __pyx_nargs); __PYX_ERR(5, 3465, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_MULT", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_LINEARREG_INTERCEPT", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real0), __pyx_ptype_5numpy_ndarray, 0, "real0", 0))) __PYX_ERR(3, 4092, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real1), __pyx_ptype_5numpy_ndarray, 0, "real1", 0))) __PYX_ERR(3, 4092, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_600stream_MULT(__pyx_self, __pyx_v_real0, __pyx_v_real1);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 3467, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_566stream_LINEARREG_INTERCEPT(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_600stream_MULT(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real0, PyArrayObject *__pyx_v_real1) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_566stream_LINEARREG_INTERCEPT(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
-  double *__pyx_v_real0_data;
-  double *__pyx_v_real1_data;
+  double *__pyx_v_real_data;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
   double __pyx_v_outreal;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  npy_intp __pyx_t_2;
-  __Pyx_RefNannySetupContext("stream_MULT", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_real0);
-  __Pyx_INCREF((PyObject *)__pyx_v_real1);
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4111, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_real0, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_v_real0_data = ((double *)__pyx_v_real0->data);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_LINEARREG_INTERCEPT", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4113, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3486, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_real1, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_real1_data = ((double *)__pyx_v_real1->data);
+  __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real));
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_real0, __pyx_v_real1); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(3, 4115, __pyx_L1_error)
-  __pyx_v_length = __pyx_t_2;
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
   __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
 
-  __pyx_v_retCode = TA_MULT((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real0_data, __pyx_v_real1_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
+  __pyx_v_retCode = TA_LINEARREG_INTERCEPT((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_MULT, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4118, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_LINEARREG_INTERCEPT, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3491, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4119, __pyx_L1_error)
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3492, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -57226,11 +70703,10 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_600stream_MULT(CYTHON_UNUSED PyObject
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_MULT", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_LINEARREG_INTERCEPT", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_real0);
-  __Pyx_XDECREF((PyObject *)__pyx_v_real1);
+  __Pyx_XDECREF((PyObject *)__pyx_v_real);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -57238,156 +70714,153 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_600stream_MULT(CYTHON_UNUSED PyObject
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_603stream_NATR(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_602stream_NATR[] = " NATR(high, low, close[, timeperiod=?])\n\n    Normalized Average True Range (Volatility Indicators)\n\n    Inputs:\n        prices: ['high', 'low', 'close']\n    Parameters:\n        timeperiod: 14\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_603stream_NATR = {"stream_NATR", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_603stream_NATR, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_602stream_NATR};
-static PyObject *__pyx_pw_5talib_7_ta_lib_603stream_NATR(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_high = 0;
-  PyArrayObject *__pyx_v_low = 0;
-  PyArrayObject *__pyx_v_close = 0;
+static PyObject *__pyx_pw_5talib_7_ta_lib_569stream_LINEARREG_SLOPE(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_568stream_LINEARREG_SLOPE, "stream_LINEARREG_SLOPE(ndarray real, int timeperiod=-0x80000000)\n\nLINEARREG_SLOPE(real[, timeperiod=?])\n\nLinear Regression Slope (Statistic Functions)\n\nInputs:\n    real: (any ndarray)\nParameters:\n    timeperiod: 14\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_569stream_LINEARREG_SLOPE = {"stream_LINEARREG_SLOPE", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_569stream_LINEARREG_SLOPE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_568stream_LINEARREG_SLOPE};
+static PyObject *__pyx_pw_5talib_7_ta_lib_569stream_LINEARREG_SLOPE(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_real = 0;
   int __pyx_v_timeperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_NATR (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_LINEARREG_SLOPE (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,&__pyx_n_s_timeperiod,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 3494, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 3494, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3494, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_NATR", 0, 3, 4, 1); __PYX_ERR(3, 4123, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_NATR", 0, 3, 4, 2); __PYX_ERR(3, 4123, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod);
-          if (value) { values[3] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_NATR") < 0)) __PYX_ERR(3, 4123, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_LINEARREG_SLOPE", 0) < (0)) __PYX_ERR(5, 3494, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_LINEARREG_SLOPE", 0, 1, 2, i); __PYX_ERR(5, 3494, __pyx_L3_error) }
       }
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 3494, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3494, __pyx_L3_error)
         break;
         default: goto __pyx_L5_argtuple_error;
       }
     }
-    __pyx_v_high = ((PyArrayObject *)values[0]);
-    __pyx_v_low = ((PyArrayObject *)values[1]);
-    __pyx_v_close = ((PyArrayObject *)values[2]);
-    if (values[3]) {
-      __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[3]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4123, __pyx_L3_error)
+    __pyx_v_real = ((PyArrayObject *)values[0]);
+    if (values[1]) {
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 3496, __pyx_L3_error)
     } else {
-      __pyx_v_timeperiod = ((int)-2147483648);
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
     }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_NATR", 0, 3, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 4123, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_LINEARREG_SLOPE", 0, 1, 2, __pyx_nargs); __PYX_ERR(5, 3494, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_NATR", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_LINEARREG_SLOPE", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 4123, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 4123, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 4123, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_602stream_NATR(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_timeperiod);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 3496, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_568stream_LINEARREG_SLOPE(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_602stream_NATR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_568stream_LINEARREG_SLOPE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
-  double *__pyx_v_high_data;
-  double *__pyx_v_low_data;
-  double *__pyx_v_close_data;
+  double *__pyx_v_real_data;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
   double __pyx_v_outreal;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  npy_intp __pyx_t_2;
-  __Pyx_RefNannySetupContext("stream_NATR", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_high);
-  __Pyx_INCREF((PyObject *)__pyx_v_low);
-  __Pyx_INCREF((PyObject *)__pyx_v_close);
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4144, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_v_high_data = ((double *)__pyx_v_high->data);
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4146, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_v_low_data = ((double *)__pyx_v_low->data);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_LINEARREG_SLOPE", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4148, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3515, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_close_data = ((double *)__pyx_v_close->data);
+  __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real));
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(3, 4150, __pyx_L1_error)
-  __pyx_v_length = __pyx_t_2;
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
   __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
 
-  __pyx_v_retCode = TA_NATR((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
+  __pyx_v_retCode = TA_LINEARREG_SLOPE((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_NATR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4153, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_LINEARREG_SLOPE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3520, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4154, __pyx_L1_error)
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3521, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -57397,12 +70870,10 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_602stream_NATR(CYTHON_UNUSED PyObject
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_NATR", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_LINEARREG_SLOPE", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_high);
-  __Pyx_XDECREF((PyObject *)__pyx_v_low);
-  __Pyx_XDECREF((PyObject *)__pyx_v_close);
+  __Pyx_XDECREF((PyObject *)__pyx_v_real);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -57410,117 +70881,136 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_602stream_NATR(CYTHON_UNUSED PyObject
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_605stream_OBV(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_604stream_OBV[] = " OBV(real, volume)\n\n    On Balance Volume (Volume Indicators)\n\n    Inputs:\n        real: (any ndarray)\n        prices: ['volume']\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_605stream_OBV = {"stream_OBV", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_605stream_OBV, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_604stream_OBV};
-static PyObject *__pyx_pw_5talib_7_ta_lib_605stream_OBV(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_571stream_LN(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_570stream_LN, "stream_LN(ndarray real)\n\nLN(real)\n\nVector Log Natural (Math Transform)\n\nInputs:\n    real: (any ndarray)\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_571stream_LN = {"stream_LN", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_571stream_LN, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_570stream_LN};
+static PyObject *__pyx_pw_5talib_7_ta_lib_571stream_LN(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_real = 0;
-  PyArrayObject *__pyx_v_volume = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_OBV (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_LN (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_volume,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);
-        CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 3523, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3523, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_volume)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_OBV", 1, 2, 2, 1); __PYX_ERR(3, 4158, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_OBV") < 0)) __PYX_ERR(3, 4158, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_LN", 0) < (0)) __PYX_ERR(5, 3523, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_LN", 1, 1, 1, i); __PYX_ERR(5, 3523, __pyx_L3_error) }
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
+    } else if (unlikely(__pyx_nargs != 1)) {
       goto __pyx_L5_argtuple_error;
     } else {
-      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3523, __pyx_L3_error)
     }
     __pyx_v_real = ((PyArrayObject *)values[0]);
-    __pyx_v_volume = ((PyArrayObject *)values[1]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_OBV", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 4158, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_LN", 1, 1, 1, __pyx_nargs); __PYX_ERR(5, 3523, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_OBV", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_LN", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 4158, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_volume), __pyx_ptype_5numpy_ndarray, 0, "volume", 0))) __PYX_ERR(3, 4158, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_604stream_OBV(__pyx_self, __pyx_v_real, __pyx_v_volume);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 3525, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_570stream_LN(__pyx_self, __pyx_v_real);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_604stream_OBV(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, PyArrayObject *__pyx_v_volume) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_570stream_LN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
   double *__pyx_v_real_data;
-  double *__pyx_v_volume_data;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
   double __pyx_v_outreal;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  npy_intp __pyx_t_2;
-  __Pyx_RefNannySetupContext("stream_OBV", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_LN", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_real);
-  __Pyx_INCREF((PyObject *)__pyx_v_volume);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4177, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3542, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_real_data = ((double *)__pyx_v_real->data);
+  __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_volume)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4179, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_volume, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_v_volume_data = ((double *)__pyx_v_volume->data);
-
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_real, __pyx_v_volume); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(3, 4181, __pyx_L1_error)
-  __pyx_v_length = __pyx_t_2;
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
   __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
 
-  __pyx_v_retCode = TA_OBV((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_volume_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
+  __pyx_v_retCode = TA_LN((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_OBV, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4184, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_LN, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3547, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4185, __pyx_L1_error)
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3548, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -57530,11 +71020,10 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_604stream_OBV(CYTHON_UNUSED PyObject *
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_OBV", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_LN", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_real);
-  __Pyx_XDECREF((PyObject *)__pyx_v_volume);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -57542,156 +71031,136 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_604stream_OBV(CYTHON_UNUSED PyObject *
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_607stream_PLUS_DI(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_606stream_PLUS_DI[] = " PLUS_DI(high, low, close[, timeperiod=?])\n\n    Plus Directional Indicator (Momentum Indicators)\n\n    Inputs:\n        prices: ['high', 'low', 'close']\n    Parameters:\n        timeperiod: 14\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_607stream_PLUS_DI = {"stream_PLUS_DI", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_607stream_PLUS_DI, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_606stream_PLUS_DI};
-static PyObject *__pyx_pw_5talib_7_ta_lib_607stream_PLUS_DI(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_high = 0;
-  PyArrayObject *__pyx_v_low = 0;
-  PyArrayObject *__pyx_v_close = 0;
-  int __pyx_v_timeperiod;
+static PyObject *__pyx_pw_5talib_7_ta_lib_573stream_LOG10(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_572stream_LOG10, "stream_LOG10(ndarray real)\n\nLOG10(real)\n\nVector Log10 (Math Transform)\n\nInputs:\n    real: (any ndarray)\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_573stream_LOG10 = {"stream_LOG10", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_573stream_LOG10, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_572stream_LOG10};
+static PyObject *__pyx_pw_5talib_7_ta_lib_573stream_LOG10(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_real = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_PLUS_DI (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_LOG10 (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,&__pyx_n_s_timeperiod,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 3550, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3550, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_PLUS_DI", 0, 3, 4, 1); __PYX_ERR(3, 4189, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_PLUS_DI", 0, 3, 4, 2); __PYX_ERR(3, 4189, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod);
-          if (value) { values[3] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_PLUS_DI") < 0)) __PYX_ERR(3, 4189, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_LOG10", 0) < (0)) __PYX_ERR(5, 3550, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_LOG10", 1, 1, 1, i); __PYX_ERR(5, 3550, __pyx_L3_error) }
       }
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-        break;
-        default: goto __pyx_L5_argtuple_error;
-      }
-    }
-    __pyx_v_high = ((PyArrayObject *)values[0]);
-    __pyx_v_low = ((PyArrayObject *)values[1]);
-    __pyx_v_close = ((PyArrayObject *)values[2]);
-    if (values[3]) {
-      __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[3]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4189, __pyx_L3_error)
-    } else {
-      __pyx_v_timeperiod = ((int)-2147483648);
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3550, __pyx_L3_error)
     }
+    __pyx_v_real = ((PyArrayObject *)values[0]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_PLUS_DI", 0, 3, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 4189, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_LOG10", 1, 1, 1, __pyx_nargs); __PYX_ERR(5, 3550, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_PLUS_DI", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_LOG10", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 4189, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 4189, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 4189, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_606stream_PLUS_DI(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_timeperiod);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 3552, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_572stream_LOG10(__pyx_self, __pyx_v_real);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_606stream_PLUS_DI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_572stream_LOG10(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
-  double *__pyx_v_high_data;
-  double *__pyx_v_low_data;
-  double *__pyx_v_close_data;
+  double *__pyx_v_real_data;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
   double __pyx_v_outreal;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  npy_intp __pyx_t_2;
-  __Pyx_RefNannySetupContext("stream_PLUS_DI", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_high);
-  __Pyx_INCREF((PyObject *)__pyx_v_low);
-  __Pyx_INCREF((PyObject *)__pyx_v_close);
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4210, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_v_high_data = ((double *)__pyx_v_high->data);
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4212, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_v_low_data = ((double *)__pyx_v_low->data);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_LOG10", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4214, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3569, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_close_data = ((double *)__pyx_v_close->data);
+  __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real));
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(3, 4216, __pyx_L1_error)
-  __pyx_v_length = __pyx_t_2;
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
   __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
 
-  __pyx_v_retCode = TA_PLUS_DI((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
+  __pyx_v_retCode = TA_LOG10((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_PLUS_DI, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4219, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_LOG10, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3574, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4220, __pyx_L1_error)
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3575, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -57701,12 +71170,10 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_606stream_PLUS_DI(CYTHON_UNUSED PyObje
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_PLUS_DI", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_LOG10", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_high);
-  __Pyx_XDECREF((PyObject *)__pyx_v_low);
-  __Pyx_XDECREF((PyObject *)__pyx_v_close);
+  __Pyx_XDECREF((PyObject *)__pyx_v_real);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -57714,135 +71181,167 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_606stream_PLUS_DI(CYTHON_UNUSED PyObje
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_609stream_PLUS_DM(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_608stream_PLUS_DM[] = " PLUS_DM(high, low[, timeperiod=?])\n\n    Plus Directional Movement (Momentum Indicators)\n\n    Inputs:\n        prices: ['high', 'low']\n    Parameters:\n        timeperiod: 14\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_609stream_PLUS_DM = {"stream_PLUS_DM", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_609stream_PLUS_DM, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_608stream_PLUS_DM};
-static PyObject *__pyx_pw_5talib_7_ta_lib_609stream_PLUS_DM(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_high = 0;
-  PyArrayObject *__pyx_v_low = 0;
+static PyObject *__pyx_pw_5talib_7_ta_lib_575stream_MA(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_574stream_MA, "stream_MA(ndarray real, int timeperiod=-0x80000000, int matype=0)\n\nMA(real[, timeperiod=?, matype=?])\n\nMoving average (Overlap Studies)\n\nInputs:\n    real: (any ndarray)\nParameters:\n    timeperiod: 30\n    matype: 0 (Simple Moving Average)\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_575stream_MA = {"stream_MA", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_575stream_MA, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_574stream_MA};
+static PyObject *__pyx_pw_5talib_7_ta_lib_575stream_MA(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_real = 0;
   int __pyx_v_timeperiod;
+  int __pyx_v_matype;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[3] = {0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_PLUS_DM (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_MA (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_timeperiod,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);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,&__pyx_mstate_global->__pyx_n_u_matype,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 3577, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 3577, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 3577, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3577, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_PLUS_DM", 0, 2, 3, 1); __PYX_ERR(3, 4224, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod);
-          if (value) { values[2] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_PLUS_DM") < 0)) __PYX_ERR(3, 4224, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_MA", 0) < (0)) __PYX_ERR(5, 3577, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_MA", 0, 1, 3, i); __PYX_ERR(5, 3577, __pyx_L3_error) }
       }
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+      switch (__pyx_nargs) {
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 3577, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 3577, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3577, __pyx_L3_error)
         break;
         default: goto __pyx_L5_argtuple_error;
       }
     }
-    __pyx_v_high = ((PyArrayObject *)values[0]);
-    __pyx_v_low = ((PyArrayObject *)values[1]);
+    __pyx_v_real = ((PyArrayObject *)values[0]);
+    if (values[1]) {
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 3579, __pyx_L3_error)
+    } else {
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
+    }
     if (values[2]) {
-      __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4224, __pyx_L3_error)
+      __pyx_v_matype = __Pyx_PyLong_As_int(values[2]); if (unlikely((__pyx_v_matype == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 3579, __pyx_L3_error)
     } else {
-      __pyx_v_timeperiod = ((int)-2147483648);
+      __pyx_v_matype = ((int)((int)0));
     }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_PLUS_DM", 0, 2, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 4224, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_MA", 0, 1, 3, __pyx_nargs); __PYX_ERR(5, 3577, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_PLUS_DM", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_MA", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 4224, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 4224, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_608stream_PLUS_DM(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_timeperiod);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 3579, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_574stream_MA(__pyx_self, __pyx_v_real, __pyx_v_timeperiod, __pyx_v_matype);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_608stream_PLUS_DM(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, int __pyx_v_timeperiod) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_574stream_MA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod, int __pyx_v_matype) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
-  double *__pyx_v_high_data;
-  double *__pyx_v_low_data;
+  double *__pyx_v_real_data;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
   double __pyx_v_outreal;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  npy_intp __pyx_t_2;
-  __Pyx_RefNannySetupContext("stream_PLUS_DM", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_high);
-  __Pyx_INCREF((PyObject *)__pyx_v_low);
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4244, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_v_high_data = ((double *)__pyx_v_high->data);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_MA", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4246, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3599, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_low_data = ((double *)__pyx_v_low->data);
+  __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real));
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_high, __pyx_v_low); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(3, 4248, __pyx_L1_error)
-  __pyx_v_length = __pyx_t_2;
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
   __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
 
-  __pyx_v_retCode = TA_PLUS_DM((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_high_data, __pyx_v_low_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
+  __pyx_v_retCode = TA_MA((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, __pyx_v_matype, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_PLUS_DM, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4251, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_MA, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3604, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4252, __pyx_L1_error)
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3605, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -57852,11 +71351,10 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_608stream_PLUS_DM(CYTHON_UNUSED PyObje
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_PLUS_DM", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_MA", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_high);
-  __Pyx_XDECREF((PyObject *)__pyx_v_low);
+  __Pyx_XDECREF((PyObject *)__pyx_v_real);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -57864,154 +71362,218 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_608stream_PLUS_DM(CYTHON_UNUSED PyObje
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_611stream_PPO(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_610stream_PPO[] = " PPO(real[, fastperiod=?, slowperiod=?, matype=?])\n\n    Percentage Price Oscillator (Momentum Indicators)\n\n    Inputs:\n        real: (any ndarray)\n    Parameters:\n        fastperiod: 12\n        slowperiod: 26\n        matype: 0 (Simple Moving Average)\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_611stream_PPO = {"stream_PPO", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_611stream_PPO, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_610stream_PPO};
-static PyObject *__pyx_pw_5talib_7_ta_lib_611stream_PPO(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_577stream_MACD(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_576stream_MACD, "stream_MACD(ndarray real, int fastperiod=-0x80000000, int slowperiod=-0x80000000, int signalperiod=-0x80000000)\n\nMACD(real[, fastperiod=?, slowperiod=?, signalperiod=?])\n\nMoving Average Convergence/Divergence (Momentum Indicators)\n\nInputs:\n    real: (any ndarray)\nParameters:\n    fastperiod: 12\n    slowperiod: 26\n    signalperiod: 9\nOutputs:\n    macd\n    macdsignal\n    macdhist");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_577stream_MACD = {"stream_MACD", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_577stream_MACD, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_576stream_MACD};
+static PyObject *__pyx_pw_5talib_7_ta_lib_577stream_MACD(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_real = 0;
   int __pyx_v_fastperiod;
   int __pyx_v_slowperiod;
-  int __pyx_v_matype;
+  int __pyx_v_signalperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_PPO (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_MACD (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_fastperiod,&__pyx_n_s_slowperiod,&__pyx_n_s_matype,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_fastperiod,&__pyx_mstate_global->__pyx_n_u_slowperiod,&__pyx_mstate_global->__pyx_n_u_signalperiod,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 3607, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 3607, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 3607, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 3607, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3607, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_fastperiod);
-          if (value) { values[1] = value; kw_args--; }
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_slowperiod);
-          if (value) { values[2] = value; kw_args--; }
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_matype);
-          if (value) { values[3] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_PPO") < 0)) __PYX_ERR(3, 4256, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_MACD", 0) < (0)) __PYX_ERR(5, 3607, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_MACD", 0, 1, 4, i); __PYX_ERR(5, 3607, __pyx_L3_error) }
       }
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 3607, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 3607, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 3607, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3607, __pyx_L3_error)
         break;
         default: goto __pyx_L5_argtuple_error;
       }
     }
     __pyx_v_real = ((PyArrayObject *)values[0]);
     if (values[1]) {
-      __pyx_v_fastperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_fastperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4256, __pyx_L3_error)
+      __pyx_v_fastperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_fastperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 3609, __pyx_L3_error)
     } else {
-      __pyx_v_fastperiod = ((int)-2147483648);
+      __pyx_v_fastperiod = ((int)((int)-2147483648));
     }
     if (values[2]) {
-      __pyx_v_slowperiod = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_slowperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4256, __pyx_L3_error)
+      __pyx_v_slowperiod = __Pyx_PyLong_As_int(values[2]); if (unlikely((__pyx_v_slowperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 3609, __pyx_L3_error)
     } else {
-      __pyx_v_slowperiod = ((int)-2147483648);
+      __pyx_v_slowperiod = ((int)((int)-2147483648));
     }
     if (values[3]) {
-      __pyx_v_matype = __Pyx_PyInt_As_int(values[3]); if (unlikely((__pyx_v_matype == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4256, __pyx_L3_error)
+      __pyx_v_signalperiod = __Pyx_PyLong_As_int(values[3]); if (unlikely((__pyx_v_signalperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 3609, __pyx_L3_error)
     } else {
-      __pyx_v_matype = ((int)0);
+      __pyx_v_signalperiod = ((int)((int)-2147483648));
     }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_PPO", 0, 1, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 4256, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_MACD", 0, 1, 4, __pyx_nargs); __PYX_ERR(5, 3607, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_PPO", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_MACD", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 4256, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_610stream_PPO(__pyx_self, __pyx_v_real, __pyx_v_fastperiod, __pyx_v_slowperiod, __pyx_v_matype);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 3609, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_576stream_MACD(__pyx_self, __pyx_v_real, __pyx_v_fastperiod, __pyx_v_slowperiod, __pyx_v_signalperiod);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_610stream_PPO(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_fastperiod, int __pyx_v_slowperiod, int __pyx_v_matype) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_576stream_MACD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_fastperiod, int __pyx_v_slowperiod, int __pyx_v_signalperiod) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
   double *__pyx_v_real_data;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  double __pyx_v_outreal;
+  double __pyx_v_outmacd;
+  double __pyx_v_outmacdsignal;
+  double __pyx_v_outmacdhist;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  __Pyx_RefNannySetupContext("stream_PPO", 0);
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_MACD", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4277, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3634, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_real_data = ((double *)__pyx_v_real->data);
+  __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real));
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
-  __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
+  __pyx_v_outmacd = __pyx_v_5talib_7_ta_lib_NaN;
 
-  __pyx_v_retCode = TA_PPO((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_fastperiod, __pyx_v_slowperiod, __pyx_v_matype, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
+  __pyx_v_outmacdsignal = __pyx_v_5talib_7_ta_lib_NaN;
+
+  __pyx_v_outmacdhist = __pyx_v_5talib_7_ta_lib_NaN;
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_PPO, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4282, __pyx_L1_error)
+  __pyx_v_retCode = TA_MACD((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_fastperiod, __pyx_v_slowperiod, __pyx_v_signalperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outmacd), (&__pyx_v_outmacdsignal), (&__pyx_v_outmacdhist));
+
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_MACD, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3641, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4283, __pyx_L1_error)
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outmacd); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3642, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_r = __pyx_t_1;
+  __pyx_t_2 = PyFloat_FromDouble(__pyx_v_outmacdsignal); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 3642, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = PyFloat_FromDouble(__pyx_v_outmacdhist); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 3642, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 3642, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_GIVEREF(__pyx_t_1);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1) != (0)) __PYX_ERR(5, 3642, __pyx_L1_error);
+  __Pyx_GIVEREF(__pyx_t_2);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_2) != (0)) __PYX_ERR(5, 3642, __pyx_L1_error);
+  __Pyx_GIVEREF(__pyx_t_3);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_t_3) != (0)) __PYX_ERR(5, 3642, __pyx_L1_error);
   __pyx_t_1 = 0;
+  __pyx_t_2 = 0;
+  __pyx_t_3 = 0;
+  __pyx_r = __pyx_t_4;
+  __pyx_t_4 = 0;
   goto __pyx_L0;
 
 
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_PPO", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_AddTraceback("talib._ta_lib.stream_MACD", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_real);
@@ -58022,122 +71584,260 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_610stream_PPO(CYTHON_UNUSED PyObject *
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_613stream_ROC(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_612stream_ROC[] = " ROC(real[, timeperiod=?])\n\n    Rate of change : ((real/prevPrice)-1)*100 (Momentum Indicators)\n\n    Inputs:\n        real: (any ndarray)\n    Parameters:\n        timeperiod: 10\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_613stream_ROC = {"stream_ROC", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_613stream_ROC, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_612stream_ROC};
-static PyObject *__pyx_pw_5talib_7_ta_lib_613stream_ROC(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_579stream_MACDEXT(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_578stream_MACDEXT, "stream_MACDEXT(ndarray real, int fastperiod=-0x80000000, int fastmatype=0, int slowperiod=-0x80000000, int slowmatype=0, int signalperiod=-0x80000000, int signalmatype=0)\n\nMACDEXT(real[, fastperiod=?, fastmatype=?, slowperiod=?, slowmatype=?, signalperiod=?, signalmatype=?])\n\nMACD with controllable MA type (Momentum Indicators)\n\nInputs:\n    real: (any ndarray)\nParameters:\n    fastperiod: 12\n    fastmatype: 0\n    slowperiod: 26\n    slowmatype: 0\n    signalperiod: 9\n    signalmatype: 0\nOutputs:\n    macd\n    macdsignal\n    macdhist");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_579stream_MACDEXT = {"stream_MACDEXT", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_579stream_MACDEXT, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_578stream_MACDEXT};
+static PyObject *__pyx_pw_5talib_7_ta_lib_579stream_MACDEXT(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_real = 0;
-  int __pyx_v_timeperiod;
+  int __pyx_v_fastperiod;
+  int __pyx_v_fastmatype;
+  int __pyx_v_slowperiod;
+  int __pyx_v_slowmatype;
+  int __pyx_v_signalperiod;
+  int __pyx_v_signalmatype;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[7] = {0,0,0,0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_ROC (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_MACDEXT (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,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);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_fastperiod,&__pyx_mstate_global->__pyx_n_u_fastmatype,&__pyx_mstate_global->__pyx_n_u_slowperiod,&__pyx_mstate_global->__pyx_n_u_slowmatype,&__pyx_mstate_global->__pyx_n_u_signalperiod,&__pyx_mstate_global->__pyx_n_u_signalmatype,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 3644, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  7:
+        values[6] = __Pyx_ArgRef_FASTCALL(__pyx_args, 6);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(5, 3644, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  6:
+        values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(5, 3644, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  0: break;
-        default: goto __pyx_L5_argtuple_error;
-      }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
+        case  5:
+        values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(5, 3644, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 3644, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 3644, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 3644, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  1:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod);
-          if (value) { values[1] = value; kw_args--; }
-        }
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3644, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
       }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_ROC") < 0)) __PYX_ERR(3, 4287, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_MACDEXT", 0) < (0)) __PYX_ERR(5, 3644, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_MACDEXT", 0, 1, 7, i); __PYX_ERR(5, 3644, __pyx_L3_error) }
       }
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      switch (__pyx_nargs) {
+        case  7:
+        values[6] = __Pyx_ArgRef_FASTCALL(__pyx_args, 6);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(5, 3644, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  6:
+        values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(5, 3644, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  5:
+        values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(5, 3644, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 3644, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 3644, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 3644, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3644, __pyx_L3_error)
         break;
         default: goto __pyx_L5_argtuple_error;
       }
     }
     __pyx_v_real = ((PyArrayObject *)values[0]);
     if (values[1]) {
-      __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4287, __pyx_L3_error)
+      __pyx_v_fastperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_fastperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 3646, __pyx_L3_error)
+    } else {
+      __pyx_v_fastperiod = ((int)((int)-2147483648));
+    }
+    if (values[2]) {
+      __pyx_v_fastmatype = __Pyx_PyLong_As_int(values[2]); if (unlikely((__pyx_v_fastmatype == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 3646, __pyx_L3_error)
+    } else {
+      __pyx_v_fastmatype = ((int)((int)0));
+    }
+    if (values[3]) {
+      __pyx_v_slowperiod = __Pyx_PyLong_As_int(values[3]); if (unlikely((__pyx_v_slowperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 3646, __pyx_L3_error)
+    } else {
+      __pyx_v_slowperiod = ((int)((int)-2147483648));
+    }
+    if (values[4]) {
+      __pyx_v_slowmatype = __Pyx_PyLong_As_int(values[4]); if (unlikely((__pyx_v_slowmatype == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 3646, __pyx_L3_error)
     } else {
-      __pyx_v_timeperiod = ((int)-2147483648);
+      __pyx_v_slowmatype = ((int)((int)0));
+    }
+    if (values[5]) {
+      __pyx_v_signalperiod = __Pyx_PyLong_As_int(values[5]); if (unlikely((__pyx_v_signalperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 3646, __pyx_L3_error)
+    } else {
+      __pyx_v_signalperiod = ((int)((int)-2147483648));
+    }
+    if (values[6]) {
+      __pyx_v_signalmatype = __Pyx_PyLong_As_int(values[6]); if (unlikely((__pyx_v_signalmatype == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 3646, __pyx_L3_error)
+    } else {
+      __pyx_v_signalmatype = ((int)((int)0));
     }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_ROC", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 4287, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_MACDEXT", 0, 1, 7, __pyx_nargs); __PYX_ERR(5, 3644, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_ROC", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_MACDEXT", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 4287, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_612stream_ROC(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 3646, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_578stream_MACDEXT(__pyx_self, __pyx_v_real, __pyx_v_fastperiod, __pyx_v_fastmatype, __pyx_v_slowperiod, __pyx_v_slowmatype, __pyx_v_signalperiod, __pyx_v_signalmatype);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_612stream_ROC(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_578stream_MACDEXT(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_fastperiod, int __pyx_v_fastmatype, int __pyx_v_slowperiod, int __pyx_v_slowmatype, int __pyx_v_signalperiod, int __pyx_v_signalmatype) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
   double *__pyx_v_real_data;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  double __pyx_v_outreal;
+  double __pyx_v_outmacd;
+  double __pyx_v_outmacdsignal;
+  double __pyx_v_outmacdhist;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  __Pyx_RefNannySetupContext("stream_ROC", 0);
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_MACDEXT", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4306, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3674, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_real_data = ((double *)__pyx_v_real->data);
+  __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real));
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
-  __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
+  __pyx_v_outmacd = __pyx_v_5talib_7_ta_lib_NaN;
 
-  __pyx_v_retCode = TA_ROC((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
+  __pyx_v_outmacdsignal = __pyx_v_5talib_7_ta_lib_NaN;
+
+  __pyx_v_outmacdhist = __pyx_v_5talib_7_ta_lib_NaN;
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_ROC, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4311, __pyx_L1_error)
+  __pyx_v_retCode = TA_MACDEXT((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_fastperiod, __pyx_v_fastmatype, __pyx_v_slowperiod, __pyx_v_slowmatype, __pyx_v_signalperiod, __pyx_v_signalmatype, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outmacd), (&__pyx_v_outmacdsignal), (&__pyx_v_outmacdhist));
+
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_MACDEXT, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3681, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4312, __pyx_L1_error)
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outmacd); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3682, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_r = __pyx_t_1;
+  __pyx_t_2 = PyFloat_FromDouble(__pyx_v_outmacdsignal); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 3682, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = PyFloat_FromDouble(__pyx_v_outmacdhist); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 3682, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 3682, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_GIVEREF(__pyx_t_1);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1) != (0)) __PYX_ERR(5, 3682, __pyx_L1_error);
+  __Pyx_GIVEREF(__pyx_t_2);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_2) != (0)) __PYX_ERR(5, 3682, __pyx_L1_error);
+  __Pyx_GIVEREF(__pyx_t_3);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_t_3) != (0)) __PYX_ERR(5, 3682, __pyx_L1_error);
   __pyx_t_1 = 0;
+  __pyx_t_2 = 0;
+  __pyx_t_3 = 0;
+  __pyx_r = __pyx_t_4;
+  __pyx_t_4 = 0;
   goto __pyx_L0;
 
 
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_ROC", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_AddTraceback("talib._ta_lib.stream_MACDEXT", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_real);
@@ -58148,122 +71848,190 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_612stream_ROC(CYTHON_UNUSED PyObject *
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_615stream_ROCP(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_614stream_ROCP[] = " ROCP(real[, timeperiod=?])\n\n    Rate of change Percentage: (real-prevPrice)/prevPrice (Momentum Indicators)\n\n    Inputs:\n        real: (any ndarray)\n    Parameters:\n        timeperiod: 10\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_615stream_ROCP = {"stream_ROCP", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_615stream_ROCP, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_614stream_ROCP};
-static PyObject *__pyx_pw_5talib_7_ta_lib_615stream_ROCP(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_581stream_MACDFIX(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_580stream_MACDFIX, "stream_MACDFIX(ndarray real, int signalperiod=-0x80000000)\n\nMACDFIX(real[, signalperiod=?])\n\nMoving Average Convergence/Divergence Fix 12/26 (Momentum Indicators)\n\nInputs:\n    real: (any ndarray)\nParameters:\n    signalperiod: 9\nOutputs:\n    macd\n    macdsignal\n    macdhist");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_581stream_MACDFIX = {"stream_MACDFIX", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_581stream_MACDFIX, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_580stream_MACDFIX};
+static PyObject *__pyx_pw_5talib_7_ta_lib_581stream_MACDFIX(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_real = 0;
-  int __pyx_v_timeperiod;
+  int __pyx_v_signalperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_ROCP (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_MACDFIX (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,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);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_signalperiod,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 3684, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 3684, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3684, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod);
-          if (value) { values[1] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_ROCP") < 0)) __PYX_ERR(3, 4316, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_MACDFIX", 0) < (0)) __PYX_ERR(5, 3684, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_MACDFIX", 0, 1, 2, i); __PYX_ERR(5, 3684, __pyx_L3_error) }
       }
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 3684, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3684, __pyx_L3_error)
         break;
         default: goto __pyx_L5_argtuple_error;
       }
     }
     __pyx_v_real = ((PyArrayObject *)values[0]);
     if (values[1]) {
-      __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4316, __pyx_L3_error)
+      __pyx_v_signalperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_signalperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 3686, __pyx_L3_error)
     } else {
-      __pyx_v_timeperiod = ((int)-2147483648);
+      __pyx_v_signalperiod = ((int)((int)-2147483648));
     }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_ROCP", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 4316, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_MACDFIX", 0, 1, 2, __pyx_nargs); __PYX_ERR(5, 3684, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_ROCP", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_MACDFIX", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 4316, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_614stream_ROCP(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 3686, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_580stream_MACDFIX(__pyx_self, __pyx_v_real, __pyx_v_signalperiod);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_614stream_ROCP(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_580stream_MACDFIX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_signalperiod) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
   double *__pyx_v_real_data;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  double __pyx_v_outreal;
+  double __pyx_v_outmacd;
+  double __pyx_v_outmacdsignal;
+  double __pyx_v_outmacdhist;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  __Pyx_RefNannySetupContext("stream_ROCP", 0);
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_MACDFIX", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4335, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3709, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_real_data = ((double *)__pyx_v_real->data);
+  __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real));
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
-  __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
+  __pyx_v_outmacd = __pyx_v_5talib_7_ta_lib_NaN;
 
-  __pyx_v_retCode = TA_ROCP((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
+  __pyx_v_outmacdsignal = __pyx_v_5talib_7_ta_lib_NaN;
+
+  __pyx_v_outmacdhist = __pyx_v_5talib_7_ta_lib_NaN;
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_ROCP, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4340, __pyx_L1_error)
+  __pyx_v_retCode = TA_MACDFIX((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_signalperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outmacd), (&__pyx_v_outmacdsignal), (&__pyx_v_outmacdhist));
+
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_MACDFIX, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3716, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4341, __pyx_L1_error)
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outmacd); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3717, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_r = __pyx_t_1;
+  __pyx_t_2 = PyFloat_FromDouble(__pyx_v_outmacdsignal); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 3717, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = PyFloat_FromDouble(__pyx_v_outmacdhist); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 3717, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 3717, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_GIVEREF(__pyx_t_1);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1) != (0)) __PYX_ERR(5, 3717, __pyx_L1_error);
+  __Pyx_GIVEREF(__pyx_t_2);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_2) != (0)) __PYX_ERR(5, 3717, __pyx_L1_error);
+  __Pyx_GIVEREF(__pyx_t_3);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_t_3) != (0)) __PYX_ERR(5, 3717, __pyx_L1_error);
   __pyx_t_1 = 0;
+  __pyx_t_2 = 0;
+  __pyx_t_3 = 0;
+  __pyx_r = __pyx_t_4;
+  __pyx_t_4 = 0;
   goto __pyx_L0;
 
 
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_ROCP", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_AddTraceback("talib._ta_lib.stream_MACDFIX", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_real);
@@ -58274,122 +72042,194 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_614stream_ROCP(CYTHON_UNUSED PyObject
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_617stream_ROCR(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_616stream_ROCR[] = " ROCR(real[, timeperiod=?])\n\n    Rate of change ratio: (real/prevPrice) (Momentum Indicators)\n\n    Inputs:\n        real: (any ndarray)\n    Parameters:\n        timeperiod: 10\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_617stream_ROCR = {"stream_ROCR", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_617stream_ROCR, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_616stream_ROCR};
-static PyObject *__pyx_pw_5talib_7_ta_lib_617stream_ROCR(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_583stream_MAMA(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_582stream_MAMA, "stream_MAMA(ndarray real, double fastlimit=-4e37, double slowlimit=-4e37)\n\nMAMA(real[, fastlimit=?, slowlimit=?])\n\nMESA Adaptive Moving Average (Overlap Studies)\n\nInputs:\n    real: (any ndarray)\nParameters:\n    fastlimit: 0.5\n    slowlimit: 0.05\nOutputs:\n    mama\n    fama");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_583stream_MAMA = {"stream_MAMA", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_583stream_MAMA, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_582stream_MAMA};
+static PyObject *__pyx_pw_5talib_7_ta_lib_583stream_MAMA(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_real = 0;
-  int __pyx_v_timeperiod;
+  double __pyx_v_fastlimit;
+  double __pyx_v_slowlimit;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[3] = {0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_ROCR (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_MAMA (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,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);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_fastlimit,&__pyx_mstate_global->__pyx_n_u_slowlimit,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 3719, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 3719, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 3719, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3719, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod);
-          if (value) { values[1] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_ROCR") < 0)) __PYX_ERR(3, 4345, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_MAMA", 0) < (0)) __PYX_ERR(5, 3719, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_MAMA", 0, 1, 3, i); __PYX_ERR(5, 3719, __pyx_L3_error) }
       }
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      switch (__pyx_nargs) {
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 3719, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 3719, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3719, __pyx_L3_error)
         break;
         default: goto __pyx_L5_argtuple_error;
       }
     }
     __pyx_v_real = ((PyArrayObject *)values[0]);
     if (values[1]) {
-      __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4345, __pyx_L3_error)
+      __pyx_v_fastlimit = __Pyx_PyFloat_AsDouble(values[1]); if (unlikely((__pyx_v_fastlimit == (double)-1) && PyErr_Occurred())) __PYX_ERR(5, 3721, __pyx_L3_error)
+    } else {
+      __pyx_v_fastlimit = ((double)((double)-4e37));
+    }
+    if (values[2]) {
+      __pyx_v_slowlimit = __Pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_slowlimit == (double)-1) && PyErr_Occurred())) __PYX_ERR(5, 3721, __pyx_L3_error)
     } else {
-      __pyx_v_timeperiod = ((int)-2147483648);
+      __pyx_v_slowlimit = ((double)((double)-4e37));
     }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_ROCR", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 4345, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_MAMA", 0, 1, 3, __pyx_nargs); __PYX_ERR(5, 3719, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_ROCR", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_MAMA", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 4345, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_616stream_ROCR(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 3721, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_582stream_MAMA(__pyx_self, __pyx_v_real, __pyx_v_fastlimit, __pyx_v_slowlimit);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_616stream_ROCR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_582stream_MAMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, double __pyx_v_fastlimit, double __pyx_v_slowlimit) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
   double *__pyx_v_real_data;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  double __pyx_v_outreal;
+  double __pyx_v_outmama;
+  double __pyx_v_outfama;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  __Pyx_RefNannySetupContext("stream_ROCR", 0);
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_MAMA", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4364, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3743, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_real_data = ((double *)__pyx_v_real->data);
+  __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real));
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
-  __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
+  __pyx_v_outmama = __pyx_v_5talib_7_ta_lib_NaN;
 
-  __pyx_v_retCode = TA_ROCR((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
+  __pyx_v_outfama = __pyx_v_5talib_7_ta_lib_NaN;
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_ROCR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4369, __pyx_L1_error)
+  __pyx_v_retCode = TA_MAMA((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_fastlimit, __pyx_v_slowlimit, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outmama), (&__pyx_v_outfama));
+
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_MAMA, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3749, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4370, __pyx_L1_error)
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outmama); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3750, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_r = __pyx_t_1;
+  __pyx_t_2 = PyFloat_FromDouble(__pyx_v_outfama); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 3750, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 3750, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_GIVEREF(__pyx_t_1);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1) != (0)) __PYX_ERR(5, 3750, __pyx_L1_error);
+  __Pyx_GIVEREF(__pyx_t_2);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_2) != (0)) __PYX_ERR(5, 3750, __pyx_L1_error);
   __pyx_t_1 = 0;
+  __pyx_t_2 = 0;
+  __pyx_r = __pyx_t_3;
+  __pyx_t_3 = 0;
   goto __pyx_L0;
 
 
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_ROCR", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("talib._ta_lib.stream_MAMA", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_real);
@@ -58400,112 +72240,201 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_616stream_ROCR(CYTHON_UNUSED PyObject
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_619stream_ROCR100(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_618stream_ROCR100[] = " ROCR100(real[, timeperiod=?])\n\n    Rate of change ratio 100 scale: (real/prevPrice)*100 (Momentum Indicators)\n\n    Inputs:\n        real: (any ndarray)\n    Parameters:\n        timeperiod: 10\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_619stream_ROCR100 = {"stream_ROCR100", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_619stream_ROCR100, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_618stream_ROCR100};
-static PyObject *__pyx_pw_5talib_7_ta_lib_619stream_ROCR100(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_585stream_MAVP(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_584stream_MAVP, "stream_MAVP(ndarray real, ndarray periods, int minperiod=-0x80000000, int maxperiod=-0x80000000, int matype=0)\n\nMAVP(real, periods[, minperiod=?, maxperiod=?, matype=?])\n\nMoving average with variable period (Overlap Studies)\n\nInputs:\n    real: (any ndarray)\n    periods: (any ndarray)\nParameters:\n    minperiod: 2\n    maxperiod: 30\n    matype: 0 (Simple Moving Average)\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_585stream_MAVP = {"stream_MAVP", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_585stream_MAVP, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_584stream_MAVP};
+static PyObject *__pyx_pw_5talib_7_ta_lib_585stream_MAVP(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_real = 0;
-  int __pyx_v_timeperiod;
+  PyArrayObject *__pyx_v_periods = 0;
+  int __pyx_v_minperiod;
+  int __pyx_v_maxperiod;
+  int __pyx_v_matype;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[5] = {0,0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_ROCR100 (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_MAVP (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,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);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_periods,&__pyx_mstate_global->__pyx_n_u_minperiod,&__pyx_mstate_global->__pyx_n_u_maxperiod,&__pyx_mstate_global->__pyx_n_u_matype,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 3752, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  5:
+        values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(5, 3752, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 3752, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  0: break;
-        default: goto __pyx_L5_argtuple_error;
-      }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 3752, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 3752, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  1:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod);
-          if (value) { values[1] = value; kw_args--; }
-        }
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3752, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
       }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_ROCR100") < 0)) __PYX_ERR(3, 4374, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_MAVP", 0) < (0)) __PYX_ERR(5, 3752, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_MAVP", 0, 2, 5, i); __PYX_ERR(5, 3752, __pyx_L3_error) }
       }
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      switch (__pyx_nargs) {
+        case  5:
+        values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(5, 3752, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 3752, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 3752, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 3752, __pyx_L3_error)
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3752, __pyx_L3_error)
         break;
         default: goto __pyx_L5_argtuple_error;
       }
     }
     __pyx_v_real = ((PyArrayObject *)values[0]);
-    if (values[1]) {
-      __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4374, __pyx_L3_error)
+    __pyx_v_periods = ((PyArrayObject *)values[1]);
+    if (values[2]) {
+      __pyx_v_minperiod = __Pyx_PyLong_As_int(values[2]); if (unlikely((__pyx_v_minperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 3754, __pyx_L3_error)
+    } else {
+      __pyx_v_minperiod = ((int)((int)-2147483648));
+    }
+    if (values[3]) {
+      __pyx_v_maxperiod = __Pyx_PyLong_As_int(values[3]); if (unlikely((__pyx_v_maxperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 3754, __pyx_L3_error)
+    } else {
+      __pyx_v_maxperiod = ((int)((int)-2147483648));
+    }
+    if (values[4]) {
+      __pyx_v_matype = __Pyx_PyLong_As_int(values[4]); if (unlikely((__pyx_v_matype == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 3754, __pyx_L3_error)
     } else {
-      __pyx_v_timeperiod = ((int)-2147483648);
+      __pyx_v_matype = ((int)((int)0));
     }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_ROCR100", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 4374, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_MAVP", 0, 2, 5, __pyx_nargs); __PYX_ERR(5, 3752, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_ROCR100", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_MAVP", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 4374, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_618stream_ROCR100(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 3754, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_periods), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "periods", 0))) __PYX_ERR(5, 3754, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_584stream_MAVP(__pyx_self, __pyx_v_real, __pyx_v_periods, __pyx_v_minperiod, __pyx_v_maxperiod, __pyx_v_matype);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_618stream_ROCR100(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_584stream_MAVP(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, PyArrayObject *__pyx_v_periods, int __pyx_v_minperiod, int __pyx_v_maxperiod, int __pyx_v_matype) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
   double *__pyx_v_real_data;
+  double *__pyx_v_periods_data;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
   double __pyx_v_outreal;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  __Pyx_RefNannySetupContext("stream_ROCR100", 0);
+  npy_intp __pyx_t_2;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_MAVP", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_real);
+  __Pyx_INCREF((PyObject *)__pyx_v_periods);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4393, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3777, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_real_data = ((double *)__pyx_v_real->data);
+  __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real));
+
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_periods)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3779, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_periods, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
+
+  __pyx_v_periods_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_periods));
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_real, __pyx_v_periods); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 3781, __pyx_L1_error)
+  __pyx_v_length = __pyx_t_2;
 
   __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
 
-  __pyx_v_retCode = TA_ROCR100((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
+  __pyx_v_retCode = TA_MAVP((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_periods_data, __pyx_v_minperiod, __pyx_v_maxperiod, __pyx_v_matype, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_ROCR100, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4398, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_MAVP, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3784, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4399, __pyx_L1_error)
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3785, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -58515,10 +72444,11 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_618stream_ROCR100(CYTHON_UNUSED PyObje
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_ROCR100", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_MAVP", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_real);
+  __Pyx_XDECREF((PyObject *)__pyx_v_periods);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -58526,81 +72456,119 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_618stream_ROCR100(CYTHON_UNUSED PyObje
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_621stream_RSI(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_620stream_RSI[] = " RSI(real[, timeperiod=?])\n\n    Relative Strength Index (Momentum Indicators)\n\n    Inputs:\n        real: (any ndarray)\n    Parameters:\n        timeperiod: 14\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_621stream_RSI = {"stream_RSI", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_621stream_RSI, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_620stream_RSI};
-static PyObject *__pyx_pw_5talib_7_ta_lib_621stream_RSI(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_587stream_MAX(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_586stream_MAX, "stream_MAX(ndarray real, int timeperiod=-0x80000000)\n\nMAX(real[, timeperiod=?])\n\nHighest value over a specified period (Math Operators)\n\nInputs:\n    real: (any ndarray)\nParameters:\n    timeperiod: 30\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_587stream_MAX = {"stream_MAX", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_587stream_MAX, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_586stream_MAX};
+static PyObject *__pyx_pw_5talib_7_ta_lib_587stream_MAX(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_real = 0;
   int __pyx_v_timeperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_RSI (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_MAX (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,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);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 3787, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 3787, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3787, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod);
-          if (value) { values[1] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_RSI") < 0)) __PYX_ERR(3, 4403, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_MAX", 0) < (0)) __PYX_ERR(5, 3787, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_MAX", 0, 1, 2, i); __PYX_ERR(5, 3787, __pyx_L3_error) }
       }
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 3787, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3787, __pyx_L3_error)
         break;
         default: goto __pyx_L5_argtuple_error;
       }
     }
     __pyx_v_real = ((PyArrayObject *)values[0]);
     if (values[1]) {
-      __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4403, __pyx_L3_error)
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 3789, __pyx_L3_error)
     } else {
-      __pyx_v_timeperiod = ((int)-2147483648);
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
     }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_RSI", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 4403, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_MAX", 0, 1, 2, __pyx_nargs); __PYX_ERR(5, 3787, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_RSI", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_MAX", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 4403, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_620stream_RSI(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 3789, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_586stream_MAX(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_620stream_RSI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_586stream_MAX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
   double *__pyx_v_real_data;
@@ -58610,28 +72578,31 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_620stream_RSI(CYTHON_UNUSED PyObject *
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  __Pyx_RefNannySetupContext("stream_RSI", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_MAX", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4422, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3808, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_real_data = ((double *)__pyx_v_real->data);
+  __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real));
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
   __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
 
-  __pyx_v_retCode = TA_RSI((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
+  __pyx_v_retCode = TA_MAX((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_RSI, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4427, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_MAX, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3813, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4428, __pyx_L1_error)
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3814, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -58641,7 +72612,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_620stream_RSI(CYTHON_UNUSED PyObject *
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_RSI", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_MAX", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_real);
@@ -58652,151 +72623,153 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_620stream_RSI(CYTHON_UNUSED PyObject *
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_623stream_SAR(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_622stream_SAR[] = " SAR(high, low[, acceleration=?, maximum=?])\n\n    Parabolic SAR (Overlap Studies)\n\n    Inputs:\n        prices: ['high', 'low']\n    Parameters:\n        acceleration: 0.02\n        maximum: 0.2\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_623stream_SAR = {"stream_SAR", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_623stream_SAR, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_622stream_SAR};
-static PyObject *__pyx_pw_5talib_7_ta_lib_623stream_SAR(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_high = 0;
-  PyArrayObject *__pyx_v_low = 0;
-  double __pyx_v_acceleration;
-  double __pyx_v_maximum;
+static PyObject *__pyx_pw_5talib_7_ta_lib_589stream_MAXINDEX(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_588stream_MAXINDEX, "stream_MAXINDEX(ndarray real, int timeperiod=-0x80000000)\n\nMAXINDEX(real[, timeperiod=?])\n\nIndex of highest value over a specified period (Math Operators)\n\nInputs:\n    real: (any ndarray)\nParameters:\n    timeperiod: 30\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_589stream_MAXINDEX = {"stream_MAXINDEX", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_589stream_MAXINDEX, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_588stream_MAXINDEX};
+static PyObject *__pyx_pw_5talib_7_ta_lib_589stream_MAXINDEX(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_real = 0;
+  int __pyx_v_timeperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_SAR (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_MAXINDEX (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_acceleration,&__pyx_n_s_maximum,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 3816, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 3816, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3816, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_SAR", 0, 2, 4, 1); __PYX_ERR(3, 4432, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_acceleration);
-          if (value) { values[2] = value; kw_args--; }
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_maximum);
-          if (value) { values[3] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_SAR") < 0)) __PYX_ERR(3, 4432, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_MAXINDEX", 0) < (0)) __PYX_ERR(5, 3816, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_MAXINDEX", 0, 1, 2, i); __PYX_ERR(5, 3816, __pyx_L3_error) }
       }
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 3816, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3816, __pyx_L3_error)
         break;
         default: goto __pyx_L5_argtuple_error;
       }
     }
-    __pyx_v_high = ((PyArrayObject *)values[0]);
-    __pyx_v_low = ((PyArrayObject *)values[1]);
-    if (values[2]) {
-      __pyx_v_acceleration = __pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_acceleration == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 4432, __pyx_L3_error)
-    } else {
-      __pyx_v_acceleration = ((double)0.02);
-    }
-    if (values[3]) {
-      __pyx_v_maximum = __pyx_PyFloat_AsDouble(values[3]); if (unlikely((__pyx_v_maximum == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 4432, __pyx_L3_error)
+    __pyx_v_real = ((PyArrayObject *)values[0]);
+    if (values[1]) {
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 3818, __pyx_L3_error)
     } else {
-      __pyx_v_maximum = ((double)0.2);
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
     }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_SAR", 0, 2, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 4432, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_MAXINDEX", 0, 1, 2, __pyx_nargs); __PYX_ERR(5, 3816, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_SAR", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_MAXINDEX", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 4432, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 4432, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_622stream_SAR(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_acceleration, __pyx_v_maximum);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 3818, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_588stream_MAXINDEX(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_622stream_SAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, double __pyx_v_acceleration, double __pyx_v_maximum) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_588stream_MAXINDEX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
-  double *__pyx_v_high_data;
-  double *__pyx_v_low_data;
+  double *__pyx_v_real_data;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  double __pyx_v_outreal;
+  int __pyx_v_outinteger;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  npy_intp __pyx_t_2;
-  __Pyx_RefNannySetupContext("stream_SAR", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_high);
-  __Pyx_INCREF((PyObject *)__pyx_v_low);
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4453, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_v_high_data = ((double *)__pyx_v_high->data);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_MAXINDEX", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4455, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3837, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_low_data = ((double *)__pyx_v_low->data);
+  __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real));
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_high, __pyx_v_low); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(3, 4457, __pyx_L1_error)
-  __pyx_v_length = __pyx_t_2;
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
-  __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
+  __pyx_v_outinteger = 0;
 
-  __pyx_v_retCode = TA_SAR((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_high_data, __pyx_v_low_data, __pyx_v_acceleration, __pyx_v_maximum, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
+  __pyx_v_retCode = TA_MAXINDEX((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_SAR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4460, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_MAXINDEX, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3842, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4461, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3843, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -58806,11 +72779,10 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_622stream_SAR(CYTHON_UNUSED PyObject *
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_SAR", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_MAXINDEX", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_high);
-  __Pyx_XDECREF((PyObject *)__pyx_v_low);
+  __Pyx_XDECREF((PyObject *)__pyx_v_real);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -58818,205 +72790,111 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_622stream_SAR(CYTHON_UNUSED PyObject *
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_625stream_SAREXT(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_624stream_SAREXT[] = " SAREXT(high, low[, startvalue=?, offsetonreverse=?, accelerationinitlong=?, accelerationlong=?, accelerationmaxlong=?, accelerationinitshort=?, accelerationshort=?, accelerationmaxshort=?])\n\n    Parabolic SAR - Extended (Overlap Studies)\n\n    Inputs:\n        prices: ['high', 'low']\n    Parameters:\n        startvalue: 0\n        offsetonreverse: 0\n        accelerationinitlong: 0.02\n        accelerationlong: 0.02\n        accelerationmaxlong: 0.2\n        accelerationinitshort: 0.02\n        accelerationshort: 0.02\n        accelerationmaxshort: 0.2\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_625stream_SAREXT = {"stream_SAREXT", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_625stream_SAREXT, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_624stream_SAREXT};
-static PyObject *__pyx_pw_5talib_7_ta_lib_625stream_SAREXT(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_591stream_MEDPRICE(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_590stream_MEDPRICE, "stream_MEDPRICE(ndarray high, ndarray low)\n\nMEDPRICE(high, low)\n\nMedian Price (Price Transform)\n\nInputs:\n    prices: ['high', 'low']\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_591stream_MEDPRICE = {"stream_MEDPRICE", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_591stream_MEDPRICE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_590stream_MEDPRICE};
+static PyObject *__pyx_pw_5talib_7_ta_lib_591stream_MEDPRICE(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
-  double __pyx_v_startvalue;
-  double __pyx_v_offsetonreverse;
-  double __pyx_v_accelerationinitlong;
-  double __pyx_v_accelerationlong;
-  double __pyx_v_accelerationmaxlong;
-  double __pyx_v_accelerationinitshort;
-  double __pyx_v_accelerationshort;
-  double __pyx_v_accelerationmaxshort;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_SAREXT (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_MEDPRICE (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_startvalue,&__pyx_n_s_offsetonreverse,&__pyx_n_s_accelerationinitlong,&__pyx_n_s_accelerationlong,&__pyx_n_s_accelerationmaxlong,&__pyx_n_s_accelerationinitshort,&__pyx_n_s_accelerationshort,&__pyx_n_s_accelerationmaxshort,0};
-    PyObject* values[10] = {0,0,0,0,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 10: values[9] = PyTuple_GET_ITEM(__pyx_args, 9);
-        CYTHON_FALLTHROUGH;
-        case  9: values[8] = PyTuple_GET_ITEM(__pyx_args, 8);
-        CYTHON_FALLTHROUGH;
-        case  8: values[7] = PyTuple_GET_ITEM(__pyx_args, 7);
-        CYTHON_FALLTHROUGH;
-        case  7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6);
-        CYTHON_FALLTHROUGH;
-        case  6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
-        CYTHON_FALLTHROUGH;
-        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
-        CYTHON_FALLTHROUGH;
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 3845, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 3845, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3845, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_SAREXT", 0, 2, 10, 1); __PYX_ERR(3, 4465, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_startvalue);
-          if (value) { values[2] = value; kw_args--; }
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_offsetonreverse);
-          if (value) { values[3] = value; kw_args--; }
-        }
-        CYTHON_FALLTHROUGH;
-        case  4:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_accelerationinitlong);
-          if (value) { values[4] = value; kw_args--; }
-        }
-        CYTHON_FALLTHROUGH;
-        case  5:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_accelerationlong);
-          if (value) { values[5] = value; kw_args--; }
-        }
-        CYTHON_FALLTHROUGH;
-        case  6:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_accelerationmaxlong);
-          if (value) { values[6] = value; kw_args--; }
-        }
-        CYTHON_FALLTHROUGH;
-        case  7:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_accelerationinitshort);
-          if (value) { values[7] = value; kw_args--; }
-        }
-        CYTHON_FALLTHROUGH;
-        case  8:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_accelerationshort);
-          if (value) { values[8] = value; kw_args--; }
-        }
-        CYTHON_FALLTHROUGH;
-        case  9:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_accelerationmaxshort);
-          if (value) { values[9] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_SAREXT") < 0)) __PYX_ERR(3, 4465, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_MEDPRICE", 0) < (0)) __PYX_ERR(5, 3845, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_MEDPRICE", 1, 2, 2, i); __PYX_ERR(5, 3845, __pyx_L3_error) }
       }
+    } else if (unlikely(__pyx_nargs != 2)) {
+      goto __pyx_L5_argtuple_error;
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case 10: values[9] = PyTuple_GET_ITEM(__pyx_args, 9);
-        CYTHON_FALLTHROUGH;
-        case  9: values[8] = PyTuple_GET_ITEM(__pyx_args, 8);
-        CYTHON_FALLTHROUGH;
-        case  8: values[7] = PyTuple_GET_ITEM(__pyx_args, 7);
-        CYTHON_FALLTHROUGH;
-        case  7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6);
-        CYTHON_FALLTHROUGH;
-        case  6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
-        CYTHON_FALLTHROUGH;
-        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
-        CYTHON_FALLTHROUGH;
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-        break;
-        default: goto __pyx_L5_argtuple_error;
-      }
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3845, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 3845, __pyx_L3_error)
     }
     __pyx_v_high = ((PyArrayObject *)values[0]);
     __pyx_v_low = ((PyArrayObject *)values[1]);
-    if (values[2]) {
-      __pyx_v_startvalue = __pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_startvalue == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 4465, __pyx_L3_error)
-    } else {
-      __pyx_v_startvalue = ((double)-4e37);
-    }
-    if (values[3]) {
-      __pyx_v_offsetonreverse = __pyx_PyFloat_AsDouble(values[3]); if (unlikely((__pyx_v_offsetonreverse == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 4465, __pyx_L3_error)
-    } else {
-      __pyx_v_offsetonreverse = ((double)-4e37);
-    }
-    if (values[4]) {
-      __pyx_v_accelerationinitlong = __pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_accelerationinitlong == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 4465, __pyx_L3_error)
-    } else {
-      __pyx_v_accelerationinitlong = ((double)-4e37);
-    }
-    if (values[5]) {
-      __pyx_v_accelerationlong = __pyx_PyFloat_AsDouble(values[5]); if (unlikely((__pyx_v_accelerationlong == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 4465, __pyx_L3_error)
-    } else {
-      __pyx_v_accelerationlong = ((double)-4e37);
-    }
-    if (values[6]) {
-      __pyx_v_accelerationmaxlong = __pyx_PyFloat_AsDouble(values[6]); if (unlikely((__pyx_v_accelerationmaxlong == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 4465, __pyx_L3_error)
-    } else {
-      __pyx_v_accelerationmaxlong = ((double)-4e37);
-    }
-    if (values[7]) {
-      __pyx_v_accelerationinitshort = __pyx_PyFloat_AsDouble(values[7]); if (unlikely((__pyx_v_accelerationinitshort == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 4465, __pyx_L3_error)
-    } else {
-      __pyx_v_accelerationinitshort = ((double)-4e37);
-    }
-    if (values[8]) {
-      __pyx_v_accelerationshort = __pyx_PyFloat_AsDouble(values[8]); if (unlikely((__pyx_v_accelerationshort == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 4465, __pyx_L3_error)
-    } else {
-      __pyx_v_accelerationshort = ((double)-4e37);
-    }
-    if (values[9]) {
-      __pyx_v_accelerationmaxshort = __pyx_PyFloat_AsDouble(values[9]); if (unlikely((__pyx_v_accelerationmaxshort == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 4465, __pyx_L3_error)
-    } else {
-      __pyx_v_accelerationmaxshort = ((double)-4e37);
-    }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_SAREXT", 0, 2, 10, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 4465, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_MEDPRICE", 1, 2, 2, __pyx_nargs); __PYX_ERR(5, 3845, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_SAREXT", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_MEDPRICE", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 4465, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 4465, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_624stream_SAREXT(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_startvalue, __pyx_v_offsetonreverse, __pyx_v_accelerationinitlong, __pyx_v_accelerationlong, __pyx_v_accelerationmaxlong, __pyx_v_accelerationinitshort, __pyx_v_accelerationshort, __pyx_v_accelerationmaxshort);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 3847, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 3847, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_590stream_MEDPRICE(__pyx_self, __pyx_v_high, __pyx_v_low);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_624stream_SAREXT(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, double __pyx_v_startvalue, double __pyx_v_offsetonreverse, double __pyx_v_accelerationinitlong, double __pyx_v_accelerationlong, double __pyx_v_accelerationmaxlong, double __pyx_v_accelerationinitshort, double __pyx_v_accelerationshort, double __pyx_v_accelerationmaxshort) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_590stream_MEDPRICE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
   double *__pyx_v_high_data;
@@ -59028,37 +72906,40 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_624stream_SAREXT(CYTHON_UNUSED PyObjec
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
-  __Pyx_RefNannySetupContext("stream_SAREXT", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_MEDPRICE", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4492, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3865, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_high_data = ((double *)__pyx_v_high->data);
+  __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4494, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3867, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_low_data = ((double *)__pyx_v_low->data);
+  __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low));
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_high, __pyx_v_low); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(3, 4496, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_high, __pyx_v_low); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 3869, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
   __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
 
-  __pyx_v_retCode = TA_SAREXT((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_high_data, __pyx_v_low_data, __pyx_v_startvalue, __pyx_v_offsetonreverse, __pyx_v_accelerationinitlong, __pyx_v_accelerationlong, __pyx_v_accelerationmaxlong, __pyx_v_accelerationinitshort, __pyx_v_accelerationshort, __pyx_v_accelerationmaxshort, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
+  __pyx_v_retCode = TA_MEDPRICE((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_high_data, __pyx_v_low_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_SAREXT, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4499, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_MEDPRICE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3872, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4500, __pyx_L1_error)
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3873, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -59068,7 +72949,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_624stream_SAREXT(CYTHON_UNUSED PyObjec
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_SAREXT", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_MEDPRICE", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_high);
@@ -59080,57 +72961,209 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_624stream_SAREXT(CYTHON_UNUSED PyObjec
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_627stream_SIN(PyObject *__pyx_self, PyObject *__pyx_v_real); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_626stream_SIN[] = " SIN(real)\n\n    Vector Trigonometric Sin (Math Transform)\n\n    Inputs:\n        real: (any ndarray)\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_627stream_SIN = {"stream_SIN", (PyCFunction)__pyx_pw_5talib_7_ta_lib_627stream_SIN, METH_O, __pyx_doc_5talib_7_ta_lib_626stream_SIN};
-static PyObject *__pyx_pw_5talib_7_ta_lib_627stream_SIN(PyObject *__pyx_self, PyObject *__pyx_v_real) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_593stream_MFI(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_592stream_MFI, "stream_MFI(ndarray high, ndarray low, ndarray close, ndarray volume, int timeperiod=-0x80000000)\n\nMFI(high, low, close, volume[, timeperiod=?])\n\nMoney Flow Index (Momentum Indicators)\n\nInputs:\n    prices: ['high', 'low', 'close', 'volume']\nParameters:\n    timeperiod: 14\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_593stream_MFI = {"stream_MFI", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_593stream_MFI, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_592stream_MFI};
+static PyObject *__pyx_pw_5talib_7_ta_lib_593stream_MFI(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_high = 0;
+  PyArrayObject *__pyx_v_low = 0;
+  PyArrayObject *__pyx_v_close = 0;
+  PyArrayObject *__pyx_v_volume = 0;
+  int __pyx_v_timeperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[5] = {0,0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_SIN (wrapper)", 0);
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 4504, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_626stream_SIN(__pyx_self, ((PyArrayObject *)__pyx_v_real));
+  __Pyx_RefNannySetupContext("stream_MFI (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,&__pyx_mstate_global->__pyx_n_u_volume,&__pyx_mstate_global->__pyx_n_u_timeperiod,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 3875, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  5:
+        values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(5, 3875, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 3875, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 3875, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 3875, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3875, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_MFI", 0) < (0)) __PYX_ERR(5, 3875, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 4; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_MFI", 0, 4, 5, i); __PYX_ERR(5, 3875, __pyx_L3_error) }
+      }
+    } else {
+      switch (__pyx_nargs) {
+        case  5:
+        values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(5, 3875, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 3875, __pyx_L3_error)
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 3875, __pyx_L3_error)
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 3875, __pyx_L3_error)
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3875, __pyx_L3_error)
+        break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+    }
+    __pyx_v_high = ((PyArrayObject *)values[0]);
+    __pyx_v_low = ((PyArrayObject *)values[1]);
+    __pyx_v_close = ((PyArrayObject *)values[2]);
+    __pyx_v_volume = ((PyArrayObject *)values[3]);
+    if (values[4]) {
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[4]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 3877, __pyx_L3_error)
+    } else {
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
+    }
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("stream_MFI", 0, 4, 5, __pyx_nargs); __PYX_ERR(5, 3875, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_MFI", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 3877, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 3877, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 3877, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_volume), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "volume", 0))) __PYX_ERR(5, 3877, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_592stream_MFI(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_volume, __pyx_v_timeperiod);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_626stream_SIN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_592stream_MFI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, PyArrayObject *__pyx_v_volume, int __pyx_v_timeperiod) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
-  double *__pyx_v_real_data;
+  double *__pyx_v_high_data;
+  double *__pyx_v_low_data;
+  double *__pyx_v_close_data;
+  double *__pyx_v_volume_data;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
   double __pyx_v_outreal;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  __Pyx_RefNannySetupContext("stream_SIN", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_real);
+  npy_intp __pyx_t_2;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_MFI", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_high);
+  __Pyx_INCREF((PyObject *)__pyx_v_low);
+  __Pyx_INCREF((PyObject *)__pyx_v_close);
+  __Pyx_INCREF((PyObject *)__pyx_v_volume);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4521, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3899, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
+
+  __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high));
+
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3901, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
+
+  __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low));
+
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3903, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
+
+  __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close));
+
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_volume)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3905, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_volume, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_real_data = ((double *)__pyx_v_real->data);
+  __pyx_v_volume_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_volume));
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length4(__pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_volume); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 3907, __pyx_L1_error)
+  __pyx_v_length = __pyx_t_2;
 
   __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
 
-  __pyx_v_retCode = TA_SIN((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
+  __pyx_v_retCode = TA_MFI((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, __pyx_v_volume_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_SIN, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4526, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_MFI, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3910, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4527, __pyx_L1_error)
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3911, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -59140,10 +73173,13 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_626stream_SIN(CYTHON_UNUSED PyObject *
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_SIN", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_MFI", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_real);
+  __Pyx_XDECREF((PyObject *)__pyx_v_high);
+  __Pyx_XDECREF((PyObject *)__pyx_v_low);
+  __Pyx_XDECREF((PyObject *)__pyx_v_close);
+  __Pyx_XDECREF((PyObject *)__pyx_v_volume);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -59151,26 +73187,119 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_626stream_SIN(CYTHON_UNUSED PyObject *
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_629stream_SINH(PyObject *__pyx_self, PyObject *__pyx_v_real); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_628stream_SINH[] = " SINH(real)\n\n    Vector Trigonometric Sinh (Math Transform)\n\n    Inputs:\n        real: (any ndarray)\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_629stream_SINH = {"stream_SINH", (PyCFunction)__pyx_pw_5talib_7_ta_lib_629stream_SINH, METH_O, __pyx_doc_5talib_7_ta_lib_628stream_SINH};
-static PyObject *__pyx_pw_5talib_7_ta_lib_629stream_SINH(PyObject *__pyx_self, PyObject *__pyx_v_real) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_595stream_MIDPOINT(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_594stream_MIDPOINT, "stream_MIDPOINT(ndarray real, int timeperiod=-0x80000000)\n\nMIDPOINT(real[, timeperiod=?])\n\nMidPoint over period (Overlap Studies)\n\nInputs:\n    real: (any ndarray)\nParameters:\n    timeperiod: 14\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_595stream_MIDPOINT = {"stream_MIDPOINT", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_595stream_MIDPOINT, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_594stream_MIDPOINT};
+static PyObject *__pyx_pw_5talib_7_ta_lib_595stream_MIDPOINT(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_real = 0;
+  int __pyx_v_timeperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_SINH (wrapper)", 0);
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 4531, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_628stream_SINH(__pyx_self, ((PyArrayObject *)__pyx_v_real));
+  __Pyx_RefNannySetupContext("stream_MIDPOINT (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 3913, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 3913, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3913, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_MIDPOINT", 0) < (0)) __PYX_ERR(5, 3913, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_MIDPOINT", 0, 1, 2, i); __PYX_ERR(5, 3913, __pyx_L3_error) }
+      }
+    } else {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 3913, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3913, __pyx_L3_error)
+        break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+    }
+    __pyx_v_real = ((PyArrayObject *)values[0]);
+    if (values[1]) {
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 3915, __pyx_L3_error)
+    } else {
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
+    }
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("stream_MIDPOINT", 0, 1, 2, __pyx_nargs); __PYX_ERR(5, 3913, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_MIDPOINT", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 3915, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_594stream_MIDPOINT(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_628stream_SINH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_594stream_MIDPOINT(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
   double *__pyx_v_real_data;
@@ -59180,28 +73309,31 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_628stream_SINH(CYTHON_UNUSED PyObject
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  __Pyx_RefNannySetupContext("stream_SINH", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_MIDPOINT", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4548, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3934, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_real_data = ((double *)__pyx_v_real->data);
+  __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real));
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
   __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
 
-  __pyx_v_retCode = TA_SINH((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
+  __pyx_v_retCode = TA_MIDPOINT((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_SINH, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4553, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_MIDPOINT, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3939, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4554, __pyx_L1_error)
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3940, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -59211,7 +73343,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_628stream_SINH(CYTHON_UNUSED PyObject
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_SINH", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_MIDPOINT", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_real);
@@ -59222,112 +73354,173 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_628stream_SINH(CYTHON_UNUSED PyObject
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_631stream_SMA(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_630stream_SMA[] = " SMA(real[, timeperiod=?])\n\n    Simple Moving Average (Overlap Studies)\n\n    Inputs:\n        real: (any ndarray)\n    Parameters:\n        timeperiod: 30\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_631stream_SMA = {"stream_SMA", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_631stream_SMA, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_630stream_SMA};
-static PyObject *__pyx_pw_5talib_7_ta_lib_631stream_SMA(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_real = 0;
+static PyObject *__pyx_pw_5talib_7_ta_lib_597stream_MIDPRICE(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_596stream_MIDPRICE, "stream_MIDPRICE(ndarray high, ndarray low, int timeperiod=-0x80000000)\n\nMIDPRICE(high, low[, timeperiod=?])\n\nMidpoint Price over period (Overlap Studies)\n\nInputs:\n    prices: ['high', 'low']\nParameters:\n    timeperiod: 14\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_597stream_MIDPRICE = {"stream_MIDPRICE", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_597stream_MIDPRICE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_596stream_MIDPRICE};
+static PyObject *__pyx_pw_5talib_7_ta_lib_597stream_MIDPRICE(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_high = 0;
+  PyArrayObject *__pyx_v_low = 0;
   int __pyx_v_timeperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[3] = {0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_SMA (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_MIDPRICE (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,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);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_timeperiod,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 3942, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 3942, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 3942, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3942, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod);
-          if (value) { values[1] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_SMA") < 0)) __PYX_ERR(3, 4558, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_MIDPRICE", 0) < (0)) __PYX_ERR(5, 3942, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_MIDPRICE", 0, 2, 3, i); __PYX_ERR(5, 3942, __pyx_L3_error) }
       }
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      switch (__pyx_nargs) {
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 3942, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 3942, __pyx_L3_error)
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3942, __pyx_L3_error)
         break;
         default: goto __pyx_L5_argtuple_error;
       }
     }
-    __pyx_v_real = ((PyArrayObject *)values[0]);
-    if (values[1]) {
-      __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4558, __pyx_L3_error)
+    __pyx_v_high = ((PyArrayObject *)values[0]);
+    __pyx_v_low = ((PyArrayObject *)values[1]);
+    if (values[2]) {
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[2]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 3944, __pyx_L3_error)
     } else {
-      __pyx_v_timeperiod = ((int)-2147483648);
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
     }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_SMA", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 4558, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_MIDPRICE", 0, 2, 3, __pyx_nargs); __PYX_ERR(5, 3942, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_SMA", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_MIDPRICE", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 4558, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_630stream_SMA(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 3944, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 3944, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_596stream_MIDPRICE(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_timeperiod);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_630stream_SMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_596stream_MIDPRICE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, int __pyx_v_timeperiod) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
-  double *__pyx_v_real_data;
+  double *__pyx_v_high_data;
+  double *__pyx_v_low_data;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
   double __pyx_v_outreal;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  __Pyx_RefNannySetupContext("stream_SMA", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_real);
+  npy_intp __pyx_t_2;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_MIDPRICE", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_high);
+  __Pyx_INCREF((PyObject *)__pyx_v_low);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4577, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3964, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
+
+  __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high));
+
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3966, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_real_data = ((double *)__pyx_v_real->data);
+  __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low));
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_high, __pyx_v_low); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 3968, __pyx_L1_error)
+  __pyx_v_length = __pyx_t_2;
 
   __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
 
-  __pyx_v_retCode = TA_SMA((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
+  __pyx_v_retCode = TA_MIDPRICE((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_high_data, __pyx_v_low_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_SMA, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4582, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_MIDPRICE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3971, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4583, __pyx_L1_error)
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3972, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -59337,10 +73530,11 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_630stream_SMA(CYTHON_UNUSED PyObject *
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_SMA", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_MIDPRICE", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_real);
+  __Pyx_XDECREF((PyObject *)__pyx_v_high);
+  __Pyx_XDECREF((PyObject *)__pyx_v_low);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -59348,26 +73542,119 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_630stream_SMA(CYTHON_UNUSED PyObject *
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_633stream_SQRT(PyObject *__pyx_self, PyObject *__pyx_v_real); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_632stream_SQRT[] = " SQRT(real)\n\n    Vector Square Root (Math Transform)\n\n    Inputs:\n        real: (any ndarray)\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_633stream_SQRT = {"stream_SQRT", (PyCFunction)__pyx_pw_5talib_7_ta_lib_633stream_SQRT, METH_O, __pyx_doc_5talib_7_ta_lib_632stream_SQRT};
-static PyObject *__pyx_pw_5talib_7_ta_lib_633stream_SQRT(PyObject *__pyx_self, PyObject *__pyx_v_real) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_599stream_MIN(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_598stream_MIN, "stream_MIN(ndarray real, int timeperiod=-0x80000000)\n\nMIN(real[, timeperiod=?])\n\nLowest value over a specified period (Math Operators)\n\nInputs:\n    real: (any ndarray)\nParameters:\n    timeperiod: 30\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_599stream_MIN = {"stream_MIN", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_599stream_MIN, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_598stream_MIN};
+static PyObject *__pyx_pw_5talib_7_ta_lib_599stream_MIN(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_real = 0;
+  int __pyx_v_timeperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_SQRT (wrapper)", 0);
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 4587, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_632stream_SQRT(__pyx_self, ((PyArrayObject *)__pyx_v_real));
+  __Pyx_RefNannySetupContext("stream_MIN (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 3974, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 3974, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3974, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_MIN", 0) < (0)) __PYX_ERR(5, 3974, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_MIN", 0, 1, 2, i); __PYX_ERR(5, 3974, __pyx_L3_error) }
+      }
+    } else {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 3974, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3974, __pyx_L3_error)
+        break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+    }
+    __pyx_v_real = ((PyArrayObject *)values[0]);
+    if (values[1]) {
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 3976, __pyx_L3_error)
+    } else {
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
+    }
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("stream_MIN", 0, 1, 2, __pyx_nargs); __PYX_ERR(5, 3974, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_MIN", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 3976, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_598stream_MIN(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_632stream_SQRT(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_598stream_MIN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
   double *__pyx_v_real_data;
@@ -59377,28 +73664,31 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_632stream_SQRT(CYTHON_UNUSED PyObject
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  __Pyx_RefNannySetupContext("stream_SQRT", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_MIN", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4604, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3995, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_real_data = ((double *)__pyx_v_real->data);
+  __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real));
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
   __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
 
-  __pyx_v_retCode = TA_SQRT((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
+  __pyx_v_retCode = TA_MIN((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_SQRT, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4609, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_MIN, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4000, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4610, __pyx_L1_error)
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4001, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -59408,7 +73698,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_632stream_SQRT(CYTHON_UNUSED PyObject
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_SQRT", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_MIN", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_real);
@@ -59419,128 +73709,153 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_632stream_SQRT(CYTHON_UNUSED PyObject
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_635stream_STDDEV(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_634stream_STDDEV[] = " STDDEV(real[, timeperiod=?, nbdev=?])\n\n    Standard Deviation (Statistic Functions)\n\n    Inputs:\n        real: (any ndarray)\n    Parameters:\n        timeperiod: 5\n        nbdev: 1\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_635stream_STDDEV = {"stream_STDDEV", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_635stream_STDDEV, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_634stream_STDDEV};
-static PyObject *__pyx_pw_5talib_7_ta_lib_635stream_STDDEV(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_601stream_MININDEX(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_600stream_MININDEX, "stream_MININDEX(ndarray real, int timeperiod=-0x80000000)\n\nMININDEX(real[, timeperiod=?])\n\nIndex of lowest value over a specified period (Math Operators)\n\nInputs:\n    real: (any ndarray)\nParameters:\n    timeperiod: 30\nOutputs:\n    integer (values are -100, 0 or 100)");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_601stream_MININDEX = {"stream_MININDEX", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_601stream_MININDEX, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_600stream_MININDEX};
+static PyObject *__pyx_pw_5talib_7_ta_lib_601stream_MININDEX(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_real = 0;
   int __pyx_v_timeperiod;
-  double __pyx_v_nbdev;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_STDDEV (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_MININDEX (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,&__pyx_n_s_nbdev,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);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 4003, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4003, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4003, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod);
-          if (value) { values[1] = value; kw_args--; }
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_nbdev);
-          if (value) { values[2] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_STDDEV") < 0)) __PYX_ERR(3, 4614, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_MININDEX", 0) < (0)) __PYX_ERR(5, 4003, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_MININDEX", 0, 1, 2, i); __PYX_ERR(5, 4003, __pyx_L3_error) }
       }
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4003, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4003, __pyx_L3_error)
         break;
         default: goto __pyx_L5_argtuple_error;
       }
     }
     __pyx_v_real = ((PyArrayObject *)values[0]);
     if (values[1]) {
-      __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4614, __pyx_L3_error)
-    } else {
-      __pyx_v_timeperiod = ((int)-2147483648);
-    }
-    if (values[2]) {
-      __pyx_v_nbdev = __pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_nbdev == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 4614, __pyx_L3_error)
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 4005, __pyx_L3_error)
     } else {
-      __pyx_v_nbdev = ((double)-4e37);
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
     }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_STDDEV", 0, 1, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 4614, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_MININDEX", 0, 1, 2, __pyx_nargs); __PYX_ERR(5, 4003, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_STDDEV", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_MININDEX", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 4614, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_634stream_STDDEV(__pyx_self, __pyx_v_real, __pyx_v_timeperiod, __pyx_v_nbdev);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 4005, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_600stream_MININDEX(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_634stream_STDDEV(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod, double __pyx_v_nbdev) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_600stream_MININDEX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
   double *__pyx_v_real_data;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  double __pyx_v_outreal;
+  int __pyx_v_outinteger;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  __Pyx_RefNannySetupContext("stream_STDDEV", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_MININDEX", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4634, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4024, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_real_data = ((double *)__pyx_v_real->data);
+  __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real));
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
-  __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
+  __pyx_v_outinteger = 0;
 
-  __pyx_v_retCode = TA_STDDEV((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, __pyx_v_nbdev, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
+  __pyx_v_retCode = TA_MININDEX((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outinteger));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_STDDEV, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4639, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_MININDEX, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4029, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4640, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outinteger); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4030, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -59550,7 +73865,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_634stream_STDDEV(CYTHON_UNUSED PyObjec
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_STDDEV", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_MININDEX", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_real);
@@ -59561,252 +73876,183 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_634stream_STDDEV(CYTHON_UNUSED PyObjec
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_637stream_STOCH(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_636stream_STOCH[] = " STOCH(high, low, close[, fastk_period=?, slowk_period=?, slowk_matype=?, slowd_period=?, slowd_matype=?])\n\n    Stochastic (Momentum Indicators)\n\n    Inputs:\n        prices: ['high', 'low', 'close']\n    Parameters:\n        fastk_period: 5\n        slowk_period: 3\n        slowk_matype: 0\n        slowd_period: 3\n        slowd_matype: 0\n    Outputs:\n        slowk\n        slowd\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_637stream_STOCH = {"stream_STOCH", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_637stream_STOCH, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_636stream_STOCH};
-static PyObject *__pyx_pw_5talib_7_ta_lib_637stream_STOCH(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_high = 0;
-  PyArrayObject *__pyx_v_low = 0;
-  PyArrayObject *__pyx_v_close = 0;
-  int __pyx_v_fastk_period;
-  int __pyx_v_slowk_period;
-  int __pyx_v_slowk_matype;
-  int __pyx_v_slowd_period;
-  int __pyx_v_slowd_matype;
+static PyObject *__pyx_pw_5talib_7_ta_lib_603stream_MINMAX(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_602stream_MINMAX, "stream_MINMAX(ndarray real, int timeperiod=-0x80000000)\n\nMINMAX(real[, timeperiod=?])\n\nLowest and highest values over a specified period (Math Operators)\n\nInputs:\n    real: (any ndarray)\nParameters:\n    timeperiod: 30\nOutputs:\n    min\n    max");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_603stream_MINMAX = {"stream_MINMAX", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_603stream_MINMAX, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_602stream_MINMAX};
+static PyObject *__pyx_pw_5talib_7_ta_lib_603stream_MINMAX(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_real = 0;
+  int __pyx_v_timeperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_STOCH (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_MINMAX (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,&__pyx_n_s_fastk_period,&__pyx_n_s_slowk_period,&__pyx_n_s_slowk_matype,&__pyx_n_s_slowd_period,&__pyx_n_s_slowd_matype,0};
-    PyObject* values[8] = {0,0,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  8: values[7] = PyTuple_GET_ITEM(__pyx_args, 7);
-        CYTHON_FALLTHROUGH;
-        case  7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6);
-        CYTHON_FALLTHROUGH;
-        case  6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
-        CYTHON_FALLTHROUGH;
-        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
-        CYTHON_FALLTHROUGH;
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 4032, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4032, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4032, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_MINMAX", 0) < (0)) __PYX_ERR(5, 4032, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_MINMAX", 0, 1, 2, i); __PYX_ERR(5, 4032, __pyx_L3_error) }
+      }
+    } else {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4032, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_STOCH", 0, 3, 8, 1); __PYX_ERR(3, 4644, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_STOCH", 0, 3, 8, 2); __PYX_ERR(3, 4644, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_fastk_period);
-          if (value) { values[3] = value; kw_args--; }
-        }
-        CYTHON_FALLTHROUGH;
-        case  4:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_slowk_period);
-          if (value) { values[4] = value; kw_args--; }
-        }
-        CYTHON_FALLTHROUGH;
-        case  5:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_slowk_matype);
-          if (value) { values[5] = value; kw_args--; }
-        }
-        CYTHON_FALLTHROUGH;
-        case  6:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_slowd_period);
-          if (value) { values[6] = value; kw_args--; }
-        }
-        CYTHON_FALLTHROUGH;
-        case  7:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_slowd_matype);
-          if (value) { values[7] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_STOCH") < 0)) __PYX_ERR(3, 4644, __pyx_L3_error)
-      }
-    } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  8: values[7] = PyTuple_GET_ITEM(__pyx_args, 7);
-        CYTHON_FALLTHROUGH;
-        case  7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6);
-        CYTHON_FALLTHROUGH;
-        case  6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
-        CYTHON_FALLTHROUGH;
-        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
-        CYTHON_FALLTHROUGH;
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4032, __pyx_L3_error)
         break;
         default: goto __pyx_L5_argtuple_error;
       }
     }
-    __pyx_v_high = ((PyArrayObject *)values[0]);
-    __pyx_v_low = ((PyArrayObject *)values[1]);
-    __pyx_v_close = ((PyArrayObject *)values[2]);
-    if (values[3]) {
-      __pyx_v_fastk_period = __Pyx_PyInt_As_int(values[3]); if (unlikely((__pyx_v_fastk_period == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4644, __pyx_L3_error)
-    } else {
-      __pyx_v_fastk_period = ((int)-2147483648);
-    }
-    if (values[4]) {
-      __pyx_v_slowk_period = __Pyx_PyInt_As_int(values[4]); if (unlikely((__pyx_v_slowk_period == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4644, __pyx_L3_error)
-    } else {
-      __pyx_v_slowk_period = ((int)-2147483648);
-    }
-    if (values[5]) {
-      __pyx_v_slowk_matype = __Pyx_PyInt_As_int(values[5]); if (unlikely((__pyx_v_slowk_matype == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4644, __pyx_L3_error)
-    } else {
-      __pyx_v_slowk_matype = ((int)0);
-    }
-    if (values[6]) {
-      __pyx_v_slowd_period = __Pyx_PyInt_As_int(values[6]); if (unlikely((__pyx_v_slowd_period == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4644, __pyx_L3_error)
-    } else {
-      __pyx_v_slowd_period = ((int)-2147483648);
-    }
-    if (values[7]) {
-      __pyx_v_slowd_matype = __Pyx_PyInt_As_int(values[7]); if (unlikely((__pyx_v_slowd_matype == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4644, __pyx_L3_error)
+    __pyx_v_real = ((PyArrayObject *)values[0]);
+    if (values[1]) {
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 4034, __pyx_L3_error)
     } else {
-      __pyx_v_slowd_matype = ((int)0);
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
     }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_STOCH", 0, 3, 8, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 4644, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_MINMAX", 0, 1, 2, __pyx_nargs); __PYX_ERR(5, 4032, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_STOCH", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_MINMAX", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 4644, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 4644, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 4644, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_636stream_STOCH(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_fastk_period, __pyx_v_slowk_period, __pyx_v_slowk_matype, __pyx_v_slowd_period, __pyx_v_slowd_matype);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 4034, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_602stream_MINMAX(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_636stream_STOCH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_fastk_period, int __pyx_v_slowk_period, int __pyx_v_slowk_matype, int __pyx_v_slowd_period, int __pyx_v_slowd_matype) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_602stream_MINMAX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
-  double *__pyx_v_high_data;
-  double *__pyx_v_low_data;
-  double *__pyx_v_close_data;
+  double *__pyx_v_real_data;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  double __pyx_v_outslowk;
-  double __pyx_v_outslowd;
+  double __pyx_v_outmin;
+  double __pyx_v_outmax;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  npy_intp __pyx_t_2;
+  PyObject *__pyx_t_2 = NULL;
   PyObject *__pyx_t_3 = NULL;
-  PyObject *__pyx_t_4 = NULL;
-  __Pyx_RefNannySetupContext("stream_STOCH", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_high);
-  __Pyx_INCREF((PyObject *)__pyx_v_low);
-  __Pyx_INCREF((PyObject *)__pyx_v_close);
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4671, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_v_high_data = ((double *)__pyx_v_high->data);
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4673, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_v_low_data = ((double *)__pyx_v_low->data);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_MINMAX", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4675, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4055, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_close_data = ((double *)__pyx_v_close->data);
+  __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real));
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(3, 4677, __pyx_L1_error)
-  __pyx_v_length = __pyx_t_2;
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
-  __pyx_v_outslowk = __pyx_v_5talib_7_ta_lib_NaN;
+  __pyx_v_outmin = __pyx_v_5talib_7_ta_lib_NaN;
 
-  __pyx_v_outslowd = __pyx_v_5talib_7_ta_lib_NaN;
+  __pyx_v_outmax = __pyx_v_5talib_7_ta_lib_NaN;
 
-  __pyx_v_retCode = TA_STOCH((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, __pyx_v_fastk_period, __pyx_v_slowk_period, __pyx_v_slowk_matype, __pyx_v_slowd_period, __pyx_v_slowd_matype, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outslowk), (&__pyx_v_outslowd));
+  __pyx_v_retCode = TA_MINMAX((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outmin), (&__pyx_v_outmax));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_STOCH, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4681, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_MINMAX, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4061, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outslowk); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4682, __pyx_L1_error)
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outmin); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4062, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_3 = PyFloat_FromDouble(__pyx_v_outslowd); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4682, __pyx_L1_error)
+  __pyx_t_2 = PyFloat_FromDouble(__pyx_v_outmax); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 4062, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 4062, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 4682, __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);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1) != (0)) __PYX_ERR(5, 4062, __pyx_L1_error);
+  __Pyx_GIVEREF(__pyx_t_2);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_2) != (0)) __PYX_ERR(5, 4062, __pyx_L1_error);
   __pyx_t_1 = 0;
+  __pyx_t_2 = 0;
+  __pyx_r = __pyx_t_3;
   __pyx_t_3 = 0;
-  __pyx_r = __pyx_t_4;
-  __pyx_t_4 = 0;
   goto __pyx_L0;
 
 
   /* 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("talib._ta_lib.stream_STOCH", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_MINMAX", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_high);
-  __Pyx_XDECREF((PyObject *)__pyx_v_low);
-  __Pyx_XDECREF((PyObject *)__pyx_v_close);
+  __Pyx_XDECREF((PyObject *)__pyx_v_real);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -59814,220 +74060,183 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_636stream_STOCH(CYTHON_UNUSED PyObject
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_639stream_STOCHF(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_638stream_STOCHF[] = " STOCHF(high, low, close[, fastk_period=?, fastd_period=?, fastd_matype=?])\n\n    Stochastic Fast (Momentum Indicators)\n\n    Inputs:\n        prices: ['high', 'low', 'close']\n    Parameters:\n        fastk_period: 5\n        fastd_period: 3\n        fastd_matype: 0\n    Outputs:\n        fastk\n        fastd\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_639stream_STOCHF = {"stream_STOCHF", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_639stream_STOCHF, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_638stream_STOCHF};
-static PyObject *__pyx_pw_5talib_7_ta_lib_639stream_STOCHF(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_high = 0;
-  PyArrayObject *__pyx_v_low = 0;
-  PyArrayObject *__pyx_v_close = 0;
-  int __pyx_v_fastk_period;
-  int __pyx_v_fastd_period;
-  int __pyx_v_fastd_matype;
+static PyObject *__pyx_pw_5talib_7_ta_lib_605stream_MINMAXINDEX(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_604stream_MINMAXINDEX, "stream_MINMAXINDEX(ndarray real, int timeperiod=-0x80000000)\n\nMINMAXINDEX(real[, timeperiod=?])\n\nIndexes of lowest and highest values over a specified period (Math Operators)\n\nInputs:\n    real: (any ndarray)\nParameters:\n    timeperiod: 30\nOutputs:\n    minidx\n    maxidx");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_605stream_MINMAXINDEX = {"stream_MINMAXINDEX", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_605stream_MINMAXINDEX, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_604stream_MINMAXINDEX};
+static PyObject *__pyx_pw_5talib_7_ta_lib_605stream_MINMAXINDEX(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_real = 0;
+  int __pyx_v_timeperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_STOCHF (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_MINMAXINDEX (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,&__pyx_n_s_fastk_period,&__pyx_n_s_fastd_period,&__pyx_n_s_fastd_matype,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);
-        CYTHON_FALLTHROUGH;
-        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
-        CYTHON_FALLTHROUGH;
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 4064, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4064, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4064, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_STOCHF", 0, 3, 6, 1); __PYX_ERR(3, 4686, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_STOCHF", 0, 3, 6, 2); __PYX_ERR(3, 4686, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_fastk_period);
-          if (value) { values[3] = value; kw_args--; }
-        }
-        CYTHON_FALLTHROUGH;
-        case  4:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_fastd_period);
-          if (value) { values[4] = value; kw_args--; }
-        }
-        CYTHON_FALLTHROUGH;
-        case  5:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_fastd_matype);
-          if (value) { values[5] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_STOCHF") < 0)) __PYX_ERR(3, 4686, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_MINMAXINDEX", 0) < (0)) __PYX_ERR(5, 4064, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_MINMAXINDEX", 0, 1, 2, i); __PYX_ERR(5, 4064, __pyx_L3_error) }
       }
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
-        CYTHON_FALLTHROUGH;
-        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
-        CYTHON_FALLTHROUGH;
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4064, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4064, __pyx_L3_error)
         break;
         default: goto __pyx_L5_argtuple_error;
       }
     }
-    __pyx_v_high = ((PyArrayObject *)values[0]);
-    __pyx_v_low = ((PyArrayObject *)values[1]);
-    __pyx_v_close = ((PyArrayObject *)values[2]);
-    if (values[3]) {
-      __pyx_v_fastk_period = __Pyx_PyInt_As_int(values[3]); if (unlikely((__pyx_v_fastk_period == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4686, __pyx_L3_error)
-    } else {
-      __pyx_v_fastk_period = ((int)-2147483648);
-    }
-    if (values[4]) {
-      __pyx_v_fastd_period = __Pyx_PyInt_As_int(values[4]); if (unlikely((__pyx_v_fastd_period == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4686, __pyx_L3_error)
-    } else {
-      __pyx_v_fastd_period = ((int)-2147483648);
-    }
-    if (values[5]) {
-      __pyx_v_fastd_matype = __Pyx_PyInt_As_int(values[5]); if (unlikely((__pyx_v_fastd_matype == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4686, __pyx_L3_error)
+    __pyx_v_real = ((PyArrayObject *)values[0]);
+    if (values[1]) {
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 4066, __pyx_L3_error)
     } else {
-      __pyx_v_fastd_matype = ((int)0);
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
     }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_STOCHF", 0, 3, 6, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 4686, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_MINMAXINDEX", 0, 1, 2, __pyx_nargs); __PYX_ERR(5, 4064, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_STOCHF", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_MINMAXINDEX", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 4686, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 4686, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 4686, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_638stream_STOCHF(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_fastk_period, __pyx_v_fastd_period, __pyx_v_fastd_matype);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 4066, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_604stream_MINMAXINDEX(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_638stream_STOCHF(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_fastk_period, int __pyx_v_fastd_period, int __pyx_v_fastd_matype) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_604stream_MINMAXINDEX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
-  double *__pyx_v_high_data;
-  double *__pyx_v_low_data;
-  double *__pyx_v_close_data;
+  double *__pyx_v_real_data;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  double __pyx_v_outfastk;
-  double __pyx_v_outfastd;
+  int __pyx_v_outminidx;
+  int __pyx_v_outmaxidx;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  npy_intp __pyx_t_2;
+  PyObject *__pyx_t_2 = NULL;
   PyObject *__pyx_t_3 = NULL;
-  PyObject *__pyx_t_4 = NULL;
-  __Pyx_RefNannySetupContext("stream_STOCHF", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_high);
-  __Pyx_INCREF((PyObject *)__pyx_v_low);
-  __Pyx_INCREF((PyObject *)__pyx_v_close);
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4711, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_v_high_data = ((double *)__pyx_v_high->data);
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4713, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_v_low_data = ((double *)__pyx_v_low->data);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_MINMAXINDEX", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4715, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4087, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_close_data = ((double *)__pyx_v_close->data);
+  __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real));
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(3, 4717, __pyx_L1_error)
-  __pyx_v_length = __pyx_t_2;
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
-  __pyx_v_outfastk = __pyx_v_5talib_7_ta_lib_NaN;
+  __pyx_v_outminidx = 0;
 
-  __pyx_v_outfastd = __pyx_v_5talib_7_ta_lib_NaN;
+  __pyx_v_outmaxidx = 0;
 
-  __pyx_v_retCode = TA_STOCHF((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, __pyx_v_fastk_period, __pyx_v_fastd_period, __pyx_v_fastd_matype, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outfastk), (&__pyx_v_outfastd));
+  __pyx_v_retCode = TA_MINMAXINDEX((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outminidx), (&__pyx_v_outmaxidx));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_STOCHF, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4721, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_MINMAXINDEX, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4093, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outfastk); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4722, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_outminidx); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4094, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_3 = PyFloat_FromDouble(__pyx_v_outfastd); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4722, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyLong_From_int(__pyx_v_outmaxidx); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 4094, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 4094, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 4722, __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);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1) != (0)) __PYX_ERR(5, 4094, __pyx_L1_error);
+  __Pyx_GIVEREF(__pyx_t_2);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_2) != (0)) __PYX_ERR(5, 4094, __pyx_L1_error);
   __pyx_t_1 = 0;
+  __pyx_t_2 = 0;
+  __pyx_r = __pyx_t_3;
   __pyx_t_3 = 0;
-  __pyx_r = __pyx_t_4;
-  __pyx_t_4 = 0;
   goto __pyx_L0;
 
 
   /* 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("talib._ta_lib.stream_STOCHF", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_MINMAXINDEX", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_high);
-  __Pyx_XDECREF((PyObject *)__pyx_v_low);
-  __Pyx_XDECREF((PyObject *)__pyx_v_close);
+  __Pyx_XDECREF((PyObject *)__pyx_v_real);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -60035,190 +74244,206 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_638stream_STOCHF(CYTHON_UNUSED PyObjec
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_641stream_STOCHRSI(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_640stream_STOCHRSI[] = " STOCHRSI(real[, timeperiod=?, fastk_period=?, fastd_period=?, fastd_matype=?])\n\n    Stochastic Relative Strength Index (Momentum Indicators)\n\n    Inputs:\n        real: (any ndarray)\n    Parameters:\n        timeperiod: 14\n        fastk_period: 5\n        fastd_period: 3\n        fastd_matype: 0\n    Outputs:\n        fastk\n        fastd\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_641stream_STOCHRSI = {"stream_STOCHRSI", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_641stream_STOCHRSI, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_640stream_STOCHRSI};
-static PyObject *__pyx_pw_5talib_7_ta_lib_641stream_STOCHRSI(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_real = 0;
+static PyObject *__pyx_pw_5talib_7_ta_lib_607stream_MINUS_DI(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_606stream_MINUS_DI, "stream_MINUS_DI(ndarray high, ndarray low, ndarray close, int timeperiod=-0x80000000)\n\nMINUS_DI(high, low, close[, timeperiod=?])\n\nMinus Directional Indicator (Momentum Indicators)\n\nInputs:\n    prices: ['high', 'low', 'close']\nParameters:\n    timeperiod: 14\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_607stream_MINUS_DI = {"stream_MINUS_DI", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_607stream_MINUS_DI, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_606stream_MINUS_DI};
+static PyObject *__pyx_pw_5talib_7_ta_lib_607stream_MINUS_DI(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_high = 0;
+  PyArrayObject *__pyx_v_low = 0;
+  PyArrayObject *__pyx_v_close = 0;
   int __pyx_v_timeperiod;
-  int __pyx_v_fastk_period;
-  int __pyx_v_fastd_period;
-  int __pyx_v_fastd_matype;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_STOCHRSI (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_MINUS_DI (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,&__pyx_n_s_fastk_period,&__pyx_n_s_fastd_period,&__pyx_n_s_fastd_matype,0};
-    PyObject* values[5] = {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  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
-        CYTHON_FALLTHROUGH;
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,&__pyx_mstate_global->__pyx_n_u_timeperiod,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 4096, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 4096, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 4096, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4096, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4096, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod);
-          if (value) { values[1] = value; kw_args--; }
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_fastk_period);
-          if (value) { values[2] = value; kw_args--; }
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_fastd_period);
-          if (value) { values[3] = value; kw_args--; }
-        }
-        CYTHON_FALLTHROUGH;
-        case  4:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_fastd_matype);
-          if (value) { values[4] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_STOCHRSI") < 0)) __PYX_ERR(3, 4726, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_MINUS_DI", 0) < (0)) __PYX_ERR(5, 4096, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 3; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_MINUS_DI", 0, 3, 4, i); __PYX_ERR(5, 4096, __pyx_L3_error) }
       }
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
-        CYTHON_FALLTHROUGH;
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 4096, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 4096, __pyx_L3_error)
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4096, __pyx_L3_error)
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4096, __pyx_L3_error)
         break;
         default: goto __pyx_L5_argtuple_error;
       }
     }
-    __pyx_v_real = ((PyArrayObject *)values[0]);
-    if (values[1]) {
-      __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4726, __pyx_L3_error)
-    } else {
-      __pyx_v_timeperiod = ((int)-2147483648);
-    }
-    if (values[2]) {
-      __pyx_v_fastk_period = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_fastk_period == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4726, __pyx_L3_error)
-    } else {
-      __pyx_v_fastk_period = ((int)-2147483648);
-    }
+    __pyx_v_high = ((PyArrayObject *)values[0]);
+    __pyx_v_low = ((PyArrayObject *)values[1]);
+    __pyx_v_close = ((PyArrayObject *)values[2]);
     if (values[3]) {
-      __pyx_v_fastd_period = __Pyx_PyInt_As_int(values[3]); if (unlikely((__pyx_v_fastd_period == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4726, __pyx_L3_error)
-    } else {
-      __pyx_v_fastd_period = ((int)-2147483648);
-    }
-    if (values[4]) {
-      __pyx_v_fastd_matype = __Pyx_PyInt_As_int(values[4]); if (unlikely((__pyx_v_fastd_matype == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4726, __pyx_L3_error)
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[3]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 4098, __pyx_L3_error)
     } else {
-      __pyx_v_fastd_matype = ((int)0);
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
     }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_STOCHRSI", 0, 1, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 4726, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_MINUS_DI", 0, 3, 4, __pyx_nargs); __PYX_ERR(5, 4096, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_STOCHRSI", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_MINUS_DI", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 4726, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_640stream_STOCHRSI(__pyx_self, __pyx_v_real, __pyx_v_timeperiod, __pyx_v_fastk_period, __pyx_v_fastd_period, __pyx_v_fastd_matype);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 4098, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 4098, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 4098, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_606stream_MINUS_DI(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_timeperiod);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_640stream_STOCHRSI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod, int __pyx_v_fastk_period, int __pyx_v_fastd_period, int __pyx_v_fastd_matype) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_606stream_MINUS_DI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
-  double *__pyx_v_real_data;
+  double *__pyx_v_high_data;
+  double *__pyx_v_low_data;
+  double *__pyx_v_close_data;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
-  double __pyx_v_outfastk;
-  double __pyx_v_outfastd;
+  double __pyx_v_outreal;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  PyObject *__pyx_t_2 = NULL;
-  PyObject *__pyx_t_3 = NULL;
-  __Pyx_RefNannySetupContext("stream_STOCHRSI", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_real);
+  npy_intp __pyx_t_2;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_MINUS_DI", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_high);
+  __Pyx_INCREF((PyObject *)__pyx_v_low);
+  __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4750, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4119, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_real_data = ((double *)__pyx_v_real->data);
+  __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high));
+
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4121, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low));
 
-  __pyx_v_outfastk = __pyx_v_5talib_7_ta_lib_NaN;
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4123, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
 
-  __pyx_v_outfastd = __pyx_v_5talib_7_ta_lib_NaN;
+  __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close));
 
-  __pyx_v_retCode = TA_STOCHRSI((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, __pyx_v_fastk_period, __pyx_v_fastd_period, __pyx_v_fastd_matype, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outfastk), (&__pyx_v_outfastd));
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 4125, __pyx_L1_error)
+  __pyx_v_length = __pyx_t_2;
+
+  __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
+
+  __pyx_v_retCode = TA_MINUS_DI((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_STOCHRSI, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4756, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_MINUS_DI, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4128, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outfastk); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4757, __pyx_L1_error)
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4129, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = PyFloat_FromDouble(__pyx_v_outfastd); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 4757, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 4757, __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_r = __pyx_t_1;
   __pyx_t_1 = 0;
-  __pyx_t_2 = 0;
-  __pyx_r = __pyx_t_3;
-  __pyx_t_3 = 0;
   goto __pyx_L0;
 
 
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_XDECREF(__pyx_t_2);
-  __Pyx_XDECREF(__pyx_t_3);
-  __Pyx_AddTraceback("talib._ta_lib.stream_STOCHRSI", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_MINUS_DI", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_real);
+  __Pyx_XDECREF((PyObject *)__pyx_v_high);
+  __Pyx_XDECREF((PyObject *)__pyx_v_low);
+  __Pyx_XDECREF((PyObject *)__pyx_v_close);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -60226,79 +74451,132 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_640stream_STOCHRSI(CYTHON_UNUSED PyObj
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_643stream_SUB(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_642stream_SUB[] = " SUB(real0, real1)\n\n    Vector Arithmetic Substraction (Math Operators)\n\n    Inputs:\n        real0: (any ndarray)\n        real1: (any ndarray)\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_643stream_SUB = {"stream_SUB", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_643stream_SUB, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_642stream_SUB};
-static PyObject *__pyx_pw_5talib_7_ta_lib_643stream_SUB(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_real0 = 0;
-  PyArrayObject *__pyx_v_real1 = 0;
+static PyObject *__pyx_pw_5talib_7_ta_lib_609stream_MINUS_DM(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_608stream_MINUS_DM, "stream_MINUS_DM(ndarray high, ndarray low, int timeperiod=-0x80000000)\n\nMINUS_DM(high, low[, timeperiod=?])\n\nMinus Directional Movement (Momentum Indicators)\n\nInputs:\n    prices: ['high', 'low']\nParameters:\n    timeperiod: 14\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_609stream_MINUS_DM = {"stream_MINUS_DM", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_609stream_MINUS_DM, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_608stream_MINUS_DM};
+static PyObject *__pyx_pw_5talib_7_ta_lib_609stream_MINUS_DM(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_high = 0;
+  PyArrayObject *__pyx_v_low = 0;
+  int __pyx_v_timeperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[3] = {0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_SUB (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_MINUS_DM (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real0,&__pyx_n_s_real1,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);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_timeperiod,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 4131, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 4131, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4131, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4131, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real0)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real1)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_SUB", 1, 2, 2, 1); __PYX_ERR(3, 4761, __pyx_L3_error)
-        }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_MINUS_DM", 0) < (0)) __PYX_ERR(5, 4131, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_MINUS_DM", 0, 2, 3, i); __PYX_ERR(5, 4131, __pyx_L3_error) }
       }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_SUB") < 0)) __PYX_ERR(3, 4761, __pyx_L3_error)
+    } else {
+      switch (__pyx_nargs) {
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 4131, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4131, __pyx_L3_error)
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4131, __pyx_L3_error)
+        break;
+        default: goto __pyx_L5_argtuple_error;
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
-      goto __pyx_L5_argtuple_error;
+    }
+    __pyx_v_high = ((PyArrayObject *)values[0]);
+    __pyx_v_low = ((PyArrayObject *)values[1]);
+    if (values[2]) {
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[2]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 4133, __pyx_L3_error)
     } else {
-      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
     }
-    __pyx_v_real0 = ((PyArrayObject *)values[0]);
-    __pyx_v_real1 = ((PyArrayObject *)values[1]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_SUB", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 4761, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_MINUS_DM", 0, 2, 3, __pyx_nargs); __PYX_ERR(5, 4131, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_SUB", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_MINUS_DM", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real0), __pyx_ptype_5numpy_ndarray, 0, "real0", 0))) __PYX_ERR(3, 4761, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real1), __pyx_ptype_5numpy_ndarray, 0, "real1", 0))) __PYX_ERR(3, 4761, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_642stream_SUB(__pyx_self, __pyx_v_real0, __pyx_v_real1);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 4133, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 4133, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_608stream_MINUS_DM(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_timeperiod);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_642stream_SUB(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real0, PyArrayObject *__pyx_v_real1) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_608stream_MINUS_DM(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, int __pyx_v_timeperiod) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
-  double *__pyx_v_real0_data;
-  double *__pyx_v_real1_data;
+  double *__pyx_v_high_data;
+  double *__pyx_v_low_data;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
   double __pyx_v_outreal;
@@ -60306,37 +74584,40 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_642stream_SUB(CYTHON_UNUSED PyObject *
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
-  __Pyx_RefNannySetupContext("stream_SUB", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_real0);
-  __Pyx_INCREF((PyObject *)__pyx_v_real1);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_MINUS_DM", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_high);
+  __Pyx_INCREF((PyObject *)__pyx_v_low);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4780, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4153, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_real0, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_real0_data = ((double *)__pyx_v_real0->data);
+  __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4782, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4155, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_real1, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_real1_data = ((double *)__pyx_v_real1->data);
+  __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low));
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_real0, __pyx_v_real1); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(3, 4784, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_high, __pyx_v_low); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 4157, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
   __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
 
-  __pyx_v_retCode = TA_SUB((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real0_data, __pyx_v_real1_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
+  __pyx_v_retCode = TA_MINUS_DM((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_high_data, __pyx_v_low_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_SUB, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4787, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_MINUS_DM, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4160, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4788, __pyx_L1_error)
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4161, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -60346,11 +74627,11 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_642stream_SUB(CYTHON_UNUSED PyObject *
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_SUB", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_MINUS_DM", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_real0);
-  __Pyx_XDECREF((PyObject *)__pyx_v_real1);
+  __Pyx_XDECREF((PyObject *)__pyx_v_high);
+  __Pyx_XDECREF((PyObject *)__pyx_v_low);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -60358,81 +74639,119 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_642stream_SUB(CYTHON_UNUSED PyObject *
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_645stream_SUM(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_644stream_SUM[] = " SUM(real[, timeperiod=?])\n\n    Summation (Math Operators)\n\n    Inputs:\n        real: (any ndarray)\n    Parameters:\n        timeperiod: 30\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_645stream_SUM = {"stream_SUM", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_645stream_SUM, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_644stream_SUM};
-static PyObject *__pyx_pw_5talib_7_ta_lib_645stream_SUM(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_611stream_MOM(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_610stream_MOM, "stream_MOM(ndarray real, int timeperiod=-0x80000000)\n\nMOM(real[, timeperiod=?])\n\nMomentum (Momentum Indicators)\n\nInputs:\n    real: (any ndarray)\nParameters:\n    timeperiod: 10\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_611stream_MOM = {"stream_MOM", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_611stream_MOM, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_610stream_MOM};
+static PyObject *__pyx_pw_5talib_7_ta_lib_611stream_MOM(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_real = 0;
   int __pyx_v_timeperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_SUM (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_MOM (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,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);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 4163, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4163, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4163, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod);
-          if (value) { values[1] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_SUM") < 0)) __PYX_ERR(3, 4792, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_MOM", 0) < (0)) __PYX_ERR(5, 4163, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_MOM", 0, 1, 2, i); __PYX_ERR(5, 4163, __pyx_L3_error) }
       }
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4163, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4163, __pyx_L3_error)
         break;
         default: goto __pyx_L5_argtuple_error;
       }
     }
     __pyx_v_real = ((PyArrayObject *)values[0]);
     if (values[1]) {
-      __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4792, __pyx_L3_error)
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 4165, __pyx_L3_error)
     } else {
-      __pyx_v_timeperiod = ((int)-2147483648);
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
     }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_SUM", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 4792, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_MOM", 0, 1, 2, __pyx_nargs); __PYX_ERR(5, 4163, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_SUM", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_MOM", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 4792, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_644stream_SUM(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 4165, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_610stream_MOM(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_644stream_SUM(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_610stream_MOM(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
   double *__pyx_v_real_data;
@@ -60442,28 +74761,31 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_644stream_SUM(CYTHON_UNUSED PyObject *
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  __Pyx_RefNannySetupContext("stream_SUM", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_MOM", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4811, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4184, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_real_data = ((double *)__pyx_v_real->data);
+  __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real));
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
   __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
 
-  __pyx_v_retCode = TA_SUM((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
+  __pyx_v_retCode = TA_MOM((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_SUM, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4816, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_MOM, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4189, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4817, __pyx_L1_error)
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4190, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -60473,7 +74795,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_644stream_SUM(CYTHON_UNUSED PyObject *
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_SUM", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_MOM", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_real);
@@ -60484,128 +74806,156 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_644stream_SUM(CYTHON_UNUSED PyObject *
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_647stream_T3(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_646stream_T3[] = " T3(real[, timeperiod=?, vfactor=?])\n\n    Triple Exponential Moving Average (T3) (Overlap Studies)\n\n    Inputs:\n        real: (any ndarray)\n    Parameters:\n        timeperiod: 5\n        vfactor: 0.7\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_647stream_T3 = {"stream_T3", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_647stream_T3, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_646stream_T3};
-static PyObject *__pyx_pw_5talib_7_ta_lib_647stream_T3(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_real = 0;
-  int __pyx_v_timeperiod;
-  double __pyx_v_vfactor;
+static PyObject *__pyx_pw_5talib_7_ta_lib_613stream_MULT(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_612stream_MULT, "stream_MULT(ndarray real0, ndarray real1)\n\nMULT(real0, real1)\n\nVector Arithmetic Mult (Math Operators)\n\nInputs:\n    real0: (any ndarray)\n    real1: (any ndarray)\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_613stream_MULT = {"stream_MULT", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_613stream_MULT, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_612stream_MULT};
+static PyObject *__pyx_pw_5talib_7_ta_lib_613stream_MULT(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_real0 = 0;
+  PyArrayObject *__pyx_v_real1 = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_T3 (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_MULT (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,&__pyx_n_s_vfactor,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);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real0,&__pyx_mstate_global->__pyx_n_u_real1,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 4192, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4192, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4192, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod);
-          if (value) { values[1] = value; kw_args--; }
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_vfactor);
-          if (value) { values[2] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_T3") < 0)) __PYX_ERR(3, 4821, __pyx_L3_error)
-      }
-    } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-        break;
-        default: goto __pyx_L5_argtuple_error;
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_MULT", 0) < (0)) __PYX_ERR(5, 4192, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_MULT", 1, 2, 2, i); __PYX_ERR(5, 4192, __pyx_L3_error) }
       }
-    }
-    __pyx_v_real = ((PyArrayObject *)values[0]);
-    if (values[1]) {
-      __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4821, __pyx_L3_error)
-    } else {
-      __pyx_v_timeperiod = ((int)-2147483648);
-    }
-    if (values[2]) {
-      __pyx_v_vfactor = __pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_vfactor == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 4821, __pyx_L3_error)
+    } else if (unlikely(__pyx_nargs != 2)) {
+      goto __pyx_L5_argtuple_error;
     } else {
-      __pyx_v_vfactor = ((double)-4e37);
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4192, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4192, __pyx_L3_error)
     }
+    __pyx_v_real0 = ((PyArrayObject *)values[0]);
+    __pyx_v_real1 = ((PyArrayObject *)values[1]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_T3", 0, 1, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 4821, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_MULT", 1, 2, 2, __pyx_nargs); __PYX_ERR(5, 4192, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_T3", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_MULT", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 4821, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_646stream_T3(__pyx_self, __pyx_v_real, __pyx_v_timeperiod, __pyx_v_vfactor);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real0), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real0", 0))) __PYX_ERR(5, 4194, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real1), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real1", 0))) __PYX_ERR(5, 4194, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_612stream_MULT(__pyx_self, __pyx_v_real0, __pyx_v_real1);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_646stream_T3(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod, double __pyx_v_vfactor) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_612stream_MULT(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real0, PyArrayObject *__pyx_v_real1) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
-  double *__pyx_v_real_data;
+  double *__pyx_v_real0_data;
+  double *__pyx_v_real1_data;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
   double __pyx_v_outreal;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  __Pyx_RefNannySetupContext("stream_T3", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_real);
+  npy_intp __pyx_t_2;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_MULT", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_real0);
+  __Pyx_INCREF((PyObject *)__pyx_v_real1);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4841, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4213, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_real0, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
+
+  __pyx_v_real0_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real0));
+
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4215, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_real1, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_real_data = ((double *)__pyx_v_real->data);
+  __pyx_v_real1_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real1));
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_real0, __pyx_v_real1); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 4217, __pyx_L1_error)
+  __pyx_v_length = __pyx_t_2;
 
   __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
 
-  __pyx_v_retCode = TA_T3((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, __pyx_v_vfactor, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
+  __pyx_v_retCode = TA_MULT((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real0_data, __pyx_v_real1_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_T3, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4846, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_MULT, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4220, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4847, __pyx_L1_error)
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4221, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -60615,10 +74965,11 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_646stream_T3(CYTHON_UNUSED PyObject *_
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_T3", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_MULT", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_real);
+  __Pyx_XDECREF((PyObject *)__pyx_v_real0);
+  __Pyx_XDECREF((PyObject *)__pyx_v_real1);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -60626,57 +74977,191 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_646stream_T3(CYTHON_UNUSED PyObject *_
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_649stream_TAN(PyObject *__pyx_self, PyObject *__pyx_v_real); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_648stream_TAN[] = " TAN(real)\n\n    Vector Trigonometric Tan (Math Transform)\n\n    Inputs:\n        real: (any ndarray)\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_649stream_TAN = {"stream_TAN", (PyCFunction)__pyx_pw_5talib_7_ta_lib_649stream_TAN, METH_O, __pyx_doc_5talib_7_ta_lib_648stream_TAN};
-static PyObject *__pyx_pw_5talib_7_ta_lib_649stream_TAN(PyObject *__pyx_self, PyObject *__pyx_v_real) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_615stream_NATR(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_614stream_NATR, "stream_NATR(ndarray high, ndarray low, ndarray close, int timeperiod=-0x80000000)\n\nNATR(high, low, close[, timeperiod=?])\n\nNormalized Average True Range (Volatility Indicators)\n\nInputs:\n    prices: ['high', 'low', 'close']\nParameters:\n    timeperiod: 14\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_615stream_NATR = {"stream_NATR", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_615stream_NATR, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_614stream_NATR};
+static PyObject *__pyx_pw_5talib_7_ta_lib_615stream_NATR(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_high = 0;
+  PyArrayObject *__pyx_v_low = 0;
+  PyArrayObject *__pyx_v_close = 0;
+  int __pyx_v_timeperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_TAN (wrapper)", 0);
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 4851, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_648stream_TAN(__pyx_self, ((PyArrayObject *)__pyx_v_real));
-
-  /* function exit code */
-  goto __pyx_L0;
-  __pyx_L1_error:;
-  __pyx_r = NULL;
-  __pyx_L0:;
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-static PyObject *__pyx_pf_5talib_7_ta_lib_648stream_TAN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) {
-  npy_intp __pyx_v_length;
+  __Pyx_RefNannySetupContext("stream_NATR (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,&__pyx_mstate_global->__pyx_n_u_timeperiod,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 4223, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 4223, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 4223, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4223, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4223, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_NATR", 0) < (0)) __PYX_ERR(5, 4223, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 3; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_NATR", 0, 3, 4, i); __PYX_ERR(5, 4223, __pyx_L3_error) }
+      }
+    } else {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 4223, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 4223, __pyx_L3_error)
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4223, __pyx_L3_error)
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4223, __pyx_L3_error)
+        break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+    }
+    __pyx_v_high = ((PyArrayObject *)values[0]);
+    __pyx_v_low = ((PyArrayObject *)values[1]);
+    __pyx_v_close = ((PyArrayObject *)values[2]);
+    if (values[3]) {
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[3]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 4225, __pyx_L3_error)
+    } else {
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
+    }
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("stream_NATR", 0, 3, 4, __pyx_nargs); __PYX_ERR(5, 4223, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_NATR", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 4225, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 4225, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 4225, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_614stream_NATR(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_timeperiod);
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
+  __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_5talib_7_ta_lib_614stream_NATR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod) {
+  npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
-  double *__pyx_v_real_data;
+  double *__pyx_v_high_data;
+  double *__pyx_v_low_data;
+  double *__pyx_v_close_data;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
   double __pyx_v_outreal;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  __Pyx_RefNannySetupContext("stream_TAN", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_real);
+  npy_intp __pyx_t_2;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_NATR", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_high);
+  __Pyx_INCREF((PyObject *)__pyx_v_low);
+  __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4868, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4246, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
+
+  __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high));
+
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4248, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
+
+  __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low));
+
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4250, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_real_data = ((double *)__pyx_v_real->data);
+  __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close));
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 4252, __pyx_L1_error)
+  __pyx_v_length = __pyx_t_2;
 
   __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
 
-  __pyx_v_retCode = TA_TAN((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
+  __pyx_v_retCode = TA_NATR((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_TAN, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4873, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_NATR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4255, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4874, __pyx_L1_error)
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4256, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -60686,10 +75171,12 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_648stream_TAN(CYTHON_UNUSED PyObject *
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_TAN", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_NATR", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_real);
+  __Pyx_XDECREF((PyObject *)__pyx_v_high);
+  __Pyx_XDECREF((PyObject *)__pyx_v_low);
+  __Pyx_XDECREF((PyObject *)__pyx_v_close);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -60697,57 +75184,156 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_648stream_TAN(CYTHON_UNUSED PyObject *
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_651stream_TANH(PyObject *__pyx_self, PyObject *__pyx_v_real); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_650stream_TANH[] = " TANH(real)\n\n    Vector Trigonometric Tanh (Math Transform)\n\n    Inputs:\n        real: (any ndarray)\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_651stream_TANH = {"stream_TANH", (PyCFunction)__pyx_pw_5talib_7_ta_lib_651stream_TANH, METH_O, __pyx_doc_5talib_7_ta_lib_650stream_TANH};
-static PyObject *__pyx_pw_5talib_7_ta_lib_651stream_TANH(PyObject *__pyx_self, PyObject *__pyx_v_real) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_617stream_OBV(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_616stream_OBV, "stream_OBV(ndarray real, ndarray volume)\n\nOBV(real, volume)\n\nOn Balance Volume (Volume Indicators)\n\nInputs:\n    real: (any ndarray)\n    prices: ['volume']\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_617stream_OBV = {"stream_OBV", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_617stream_OBV, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_616stream_OBV};
+static PyObject *__pyx_pw_5talib_7_ta_lib_617stream_OBV(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_real = 0;
+  PyArrayObject *__pyx_v_volume = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_TANH (wrapper)", 0);
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 4878, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_650stream_TANH(__pyx_self, ((PyArrayObject *)__pyx_v_real));
+  __Pyx_RefNannySetupContext("stream_OBV (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_volume,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 4258, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4258, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4258, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_OBV", 0) < (0)) __PYX_ERR(5, 4258, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_OBV", 1, 2, 2, i); __PYX_ERR(5, 4258, __pyx_L3_error) }
+      }
+    } else if (unlikely(__pyx_nargs != 2)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4258, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4258, __pyx_L3_error)
+    }
+    __pyx_v_real = ((PyArrayObject *)values[0]);
+    __pyx_v_volume = ((PyArrayObject *)values[1]);
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("stream_OBV", 1, 2, 2, __pyx_nargs); __PYX_ERR(5, 4258, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_OBV", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 4260, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_volume), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "volume", 0))) __PYX_ERR(5, 4260, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_616stream_OBV(__pyx_self, __pyx_v_real, __pyx_v_volume);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_650stream_TANH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_616stream_OBV(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, PyArrayObject *__pyx_v_volume) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
   double *__pyx_v_real_data;
+  double *__pyx_v_volume_data;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
   double __pyx_v_outreal;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  __Pyx_RefNannySetupContext("stream_TANH", 0);
+  npy_intp __pyx_t_2;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_OBV", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_real);
+  __Pyx_INCREF((PyObject *)__pyx_v_volume);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4895, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4279, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_real_data = ((double *)__pyx_v_real->data);
+  __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real));
+
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_volume)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4281, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_volume, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
+
+  __pyx_v_volume_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_volume));
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_real, __pyx_v_volume); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 4283, __pyx_L1_error)
+  __pyx_v_length = __pyx_t_2;
 
   __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
 
-  __pyx_v_retCode = TA_TANH((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
+  __pyx_v_retCode = TA_OBV((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_volume_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_TANH, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4900, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_OBV, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4286, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4901, __pyx_L1_error)
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4287, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -60757,10 +75343,11 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_650stream_TANH(CYTHON_UNUSED PyObject
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_TANH", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_OBV", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_real);
+  __Pyx_XDECREF((PyObject *)__pyx_v_volume);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -60768,112 +75355,191 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_650stream_TANH(CYTHON_UNUSED PyObject
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_653stream_TEMA(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_652stream_TEMA[] = " TEMA(real[, timeperiod=?])\n\n    Triple Exponential Moving Average (Overlap Studies)\n\n    Inputs:\n        real: (any ndarray)\n    Parameters:\n        timeperiod: 30\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_653stream_TEMA = {"stream_TEMA", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_653stream_TEMA, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_652stream_TEMA};
-static PyObject *__pyx_pw_5talib_7_ta_lib_653stream_TEMA(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_real = 0;
+static PyObject *__pyx_pw_5talib_7_ta_lib_619stream_PLUS_DI(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_618stream_PLUS_DI, "stream_PLUS_DI(ndarray high, ndarray low, ndarray close, int timeperiod=-0x80000000)\n\nPLUS_DI(high, low, close[, timeperiod=?])\n\nPlus Directional Indicator (Momentum Indicators)\n\nInputs:\n    prices: ['high', 'low', 'close']\nParameters:\n    timeperiod: 14\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_619stream_PLUS_DI = {"stream_PLUS_DI", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_619stream_PLUS_DI, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_618stream_PLUS_DI};
+static PyObject *__pyx_pw_5talib_7_ta_lib_619stream_PLUS_DI(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_high = 0;
+  PyArrayObject *__pyx_v_low = 0;
+  PyArrayObject *__pyx_v_close = 0;
   int __pyx_v_timeperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_TEMA (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_PLUS_DI (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,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);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,&__pyx_mstate_global->__pyx_n_u_timeperiod,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 4289, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 4289, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 4289, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  0: break;
-        default: goto __pyx_L5_argtuple_error;
-      }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4289, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  1:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod);
-          if (value) { values[1] = value; kw_args--; }
-        }
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4289, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
       }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_TEMA") < 0)) __PYX_ERR(3, 4905, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_PLUS_DI", 0) < (0)) __PYX_ERR(5, 4289, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 3; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_PLUS_DI", 0, 3, 4, i); __PYX_ERR(5, 4289, __pyx_L3_error) }
       }
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 4289, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 4289, __pyx_L3_error)
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4289, __pyx_L3_error)
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4289, __pyx_L3_error)
         break;
         default: goto __pyx_L5_argtuple_error;
       }
     }
-    __pyx_v_real = ((PyArrayObject *)values[0]);
-    if (values[1]) {
-      __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4905, __pyx_L3_error)
+    __pyx_v_high = ((PyArrayObject *)values[0]);
+    __pyx_v_low = ((PyArrayObject *)values[1]);
+    __pyx_v_close = ((PyArrayObject *)values[2]);
+    if (values[3]) {
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[3]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 4291, __pyx_L3_error)
     } else {
-      __pyx_v_timeperiod = ((int)-2147483648);
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
     }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_TEMA", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 4905, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_PLUS_DI", 0, 3, 4, __pyx_nargs); __PYX_ERR(5, 4289, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_TEMA", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_PLUS_DI", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 4905, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_652stream_TEMA(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 4291, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 4291, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 4291, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_618stream_PLUS_DI(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_timeperiod);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_652stream_TEMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_618stream_PLUS_DI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
-  double *__pyx_v_real_data;
+  double *__pyx_v_high_data;
+  double *__pyx_v_low_data;
+  double *__pyx_v_close_data;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
   double __pyx_v_outreal;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  __Pyx_RefNannySetupContext("stream_TEMA", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_real);
+  npy_intp __pyx_t_2;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_PLUS_DI", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_high);
+  __Pyx_INCREF((PyObject *)__pyx_v_low);
+  __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4924, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4312, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
+
+  __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high));
+
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4314, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
+
+  __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low));
+
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4316, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_real_data = ((double *)__pyx_v_real->data);
+  __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close));
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 4318, __pyx_L1_error)
+  __pyx_v_length = __pyx_t_2;
 
   __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
 
-  __pyx_v_retCode = TA_TEMA((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
+  __pyx_v_retCode = TA_PLUS_DI((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_TEMA, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4929, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_PLUS_DI, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4321, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4930, __pyx_L1_error)
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4322, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -60883,10 +75549,12 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_652stream_TEMA(CYTHON_UNUSED PyObject
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_TEMA", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_PLUS_DI", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_real);
+  __Pyx_XDECREF((PyObject *)__pyx_v_high);
+  __Pyx_XDECREF((PyObject *)__pyx_v_low);
+  __Pyx_XDECREF((PyObject *)__pyx_v_close);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -60894,92 +75562,132 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_652stream_TEMA(CYTHON_UNUSED PyObject
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_655stream_TRANGE(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_654stream_TRANGE[] = " TRANGE(high, low, close)\n\n    True Range (Volatility Indicators)\n\n    Inputs:\n        prices: ['high', 'low', 'close']\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_655stream_TRANGE = {"stream_TRANGE", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_655stream_TRANGE, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_654stream_TRANGE};
-static PyObject *__pyx_pw_5talib_7_ta_lib_655stream_TRANGE(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_621stream_PLUS_DM(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_620stream_PLUS_DM, "stream_PLUS_DM(ndarray high, ndarray low, int timeperiod=-0x80000000)\n\nPLUS_DM(high, low[, timeperiod=?])\n\nPlus Directional Movement (Momentum Indicators)\n\nInputs:\n    prices: ['high', 'low']\nParameters:\n    timeperiod: 14\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_621stream_PLUS_DM = {"stream_PLUS_DM", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_621stream_PLUS_DM, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_620stream_PLUS_DM};
+static PyObject *__pyx_pw_5talib_7_ta_lib_621stream_PLUS_DM(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
-  PyArrayObject *__pyx_v_close = 0;
+  int __pyx_v_timeperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[3] = {0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_TRANGE (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_PLUS_DM (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,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);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_timeperiod,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 4324, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 4324, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4324, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4324, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_TRANGE", 1, 3, 3, 1); __PYX_ERR(3, 4934, __pyx_L3_error)
-        }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_PLUS_DM", 0) < (0)) __PYX_ERR(5, 4324, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_PLUS_DM", 0, 2, 3, i); __PYX_ERR(5, 4324, __pyx_L3_error) }
+      }
+    } else {
+      switch (__pyx_nargs) {
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 4324, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_TRANGE", 1, 3, 3, 2); __PYX_ERR(3, 4934, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_TRANGE") < 0)) __PYX_ERR(3, 4934, __pyx_L3_error)
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4324, __pyx_L3_error)
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4324, __pyx_L3_error)
+        break;
+        default: goto __pyx_L5_argtuple_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_high = ((PyArrayObject *)values[0]);
     __pyx_v_low = ((PyArrayObject *)values[1]);
-    __pyx_v_close = ((PyArrayObject *)values[2]);
+    if (values[2]) {
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[2]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 4326, __pyx_L3_error)
+    } else {
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
+    }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_TRANGE", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 4934, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_PLUS_DM", 0, 2, 3, __pyx_nargs); __PYX_ERR(5, 4324, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_TRANGE", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_PLUS_DM", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 4934, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 4934, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 4934, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_654stream_TRANGE(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 4326, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 4326, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_620stream_PLUS_DM(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_timeperiod);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_654stream_TRANGE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_620stream_PLUS_DM(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, int __pyx_v_timeperiod) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
   double *__pyx_v_high_data;
   double *__pyx_v_low_data;
-  double *__pyx_v_close_data;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
   double __pyx_v_outreal;
@@ -60987,45 +75695,40 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_654stream_TRANGE(CYTHON_UNUSED PyObjec
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
-  __Pyx_RefNannySetupContext("stream_TRANGE", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_PLUS_DM", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
-  __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4953, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4346, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_high_data = ((double *)__pyx_v_high->data);
+  __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4955, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4348, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_low_data = ((double *)__pyx_v_low->data);
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4957, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_v_close_data = ((double *)__pyx_v_close->data);
+  __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low));
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(3, 4959, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_high, __pyx_v_low); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 4350, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
   __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
 
-  __pyx_v_retCode = TA_TRANGE((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
+  __pyx_v_retCode = TA_PLUS_DM((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_high_data, __pyx_v_low_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_TRANGE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4962, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_PLUS_DM, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4353, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4963, __pyx_L1_error)
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4354, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -61035,12 +75738,11 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_654stream_TRANGE(CYTHON_UNUSED PyObjec
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_TRANGE", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_PLUS_DM", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_high);
   __Pyx_XDECREF((PyObject *)__pyx_v_low);
-  __Pyx_XDECREF((PyObject *)__pyx_v_close);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -61048,81 +75750,147 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_654stream_TRANGE(CYTHON_UNUSED PyObjec
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_657stream_TRIMA(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_656stream_TRIMA[] = " TRIMA(real[, timeperiod=?])\n\n    Triangular Moving Average (Overlap Studies)\n\n    Inputs:\n        real: (any ndarray)\n    Parameters:\n        timeperiod: 30\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_657stream_TRIMA = {"stream_TRIMA", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_657stream_TRIMA, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_656stream_TRIMA};
-static PyObject *__pyx_pw_5talib_7_ta_lib_657stream_TRIMA(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_623stream_PPO(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_622stream_PPO, "stream_PPO(ndarray real, int fastperiod=-0x80000000, int slowperiod=-0x80000000, int matype=0)\n\nPPO(real[, fastperiod=?, slowperiod=?, matype=?])\n\nPercentage Price Oscillator (Momentum Indicators)\n\nInputs:\n    real: (any ndarray)\nParameters:\n    fastperiod: 12\n    slowperiod: 26\n    matype: 0 (Simple Moving Average)\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_623stream_PPO = {"stream_PPO", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_623stream_PPO, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_622stream_PPO};
+static PyObject *__pyx_pw_5talib_7_ta_lib_623stream_PPO(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_real = 0;
-  int __pyx_v_timeperiod;
+  int __pyx_v_fastperiod;
+  int __pyx_v_slowperiod;
+  int __pyx_v_matype;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_TRIMA (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_PPO (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,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);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_fastperiod,&__pyx_mstate_global->__pyx_n_u_slowperiod,&__pyx_mstate_global->__pyx_n_u_matype,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 4356, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 4356, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 4356, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  0: break;
-        default: goto __pyx_L5_argtuple_error;
-      }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4356, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  1:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod);
-          if (value) { values[1] = value; kw_args--; }
-        }
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4356, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
       }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_TRIMA") < 0)) __PYX_ERR(3, 4967, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_PPO", 0) < (0)) __PYX_ERR(5, 4356, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_PPO", 0, 1, 4, i); __PYX_ERR(5, 4356, __pyx_L3_error) }
       }
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 4356, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 4356, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4356, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4356, __pyx_L3_error)
         break;
         default: goto __pyx_L5_argtuple_error;
       }
     }
     __pyx_v_real = ((PyArrayObject *)values[0]);
     if (values[1]) {
-      __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4967, __pyx_L3_error)
+      __pyx_v_fastperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_fastperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 4358, __pyx_L3_error)
+    } else {
+      __pyx_v_fastperiod = ((int)((int)-2147483648));
+    }
+    if (values[2]) {
+      __pyx_v_slowperiod = __Pyx_PyLong_As_int(values[2]); if (unlikely((__pyx_v_slowperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 4358, __pyx_L3_error)
+    } else {
+      __pyx_v_slowperiod = ((int)((int)-2147483648));
+    }
+    if (values[3]) {
+      __pyx_v_matype = __Pyx_PyLong_As_int(values[3]); if (unlikely((__pyx_v_matype == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 4358, __pyx_L3_error)
     } else {
-      __pyx_v_timeperiod = ((int)-2147483648);
+      __pyx_v_matype = ((int)((int)0));
     }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_TRIMA", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 4967, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_PPO", 0, 1, 4, __pyx_nargs); __PYX_ERR(5, 4356, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_TRIMA", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_PPO", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 4967, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_656stream_TRIMA(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 4358, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_622stream_PPO(__pyx_self, __pyx_v_real, __pyx_v_fastperiod, __pyx_v_slowperiod, __pyx_v_matype);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_656stream_TRIMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_622stream_PPO(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_fastperiod, int __pyx_v_slowperiod, int __pyx_v_matype) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
   double *__pyx_v_real_data;
@@ -61132,28 +75900,31 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_656stream_TRIMA(CYTHON_UNUSED PyObject
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  __Pyx_RefNannySetupContext("stream_TRIMA", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_PPO", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4986, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4379, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_real_data = ((double *)__pyx_v_real->data);
+  __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real));
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
   __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
 
-  __pyx_v_retCode = TA_TRIMA((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
+  __pyx_v_retCode = TA_PPO((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_fastperiod, __pyx_v_slowperiod, __pyx_v_matype, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_TRIMA, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4991, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_PPO, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4384, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 4992, __pyx_L1_error)
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4385, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -61163,7 +75934,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_656stream_TRIMA(CYTHON_UNUSED PyObject
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_TRIMA", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_PPO", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_real);
@@ -61174,81 +75945,119 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_656stream_TRIMA(CYTHON_UNUSED PyObject
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_659stream_TRIX(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_658stream_TRIX[] = " TRIX(real[, timeperiod=?])\n\n    1-day Rate-Of-Change (ROC) of a Triple Smooth EMA (Momentum Indicators)\n\n    Inputs:\n        real: (any ndarray)\n    Parameters:\n        timeperiod: 30\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_659stream_TRIX = {"stream_TRIX", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_659stream_TRIX, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_658stream_TRIX};
-static PyObject *__pyx_pw_5talib_7_ta_lib_659stream_TRIX(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_625stream_ROC(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_624stream_ROC, "stream_ROC(ndarray real, int timeperiod=-0x80000000)\n\nROC(real[, timeperiod=?])\n\nRate of change : ((real/prevPrice)-1)*100 (Momentum Indicators)\n\nInputs:\n    real: (any ndarray)\nParameters:\n    timeperiod: 10\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_625stream_ROC = {"stream_ROC", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_625stream_ROC, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_624stream_ROC};
+static PyObject *__pyx_pw_5talib_7_ta_lib_625stream_ROC(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_real = 0;
   int __pyx_v_timeperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_TRIX (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_ROC (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,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);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 4387, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4387, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4387, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod);
-          if (value) { values[1] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_TRIX") < 0)) __PYX_ERR(3, 4996, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_ROC", 0) < (0)) __PYX_ERR(5, 4387, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_ROC", 0, 1, 2, i); __PYX_ERR(5, 4387, __pyx_L3_error) }
       }
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4387, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4387, __pyx_L3_error)
         break;
         default: goto __pyx_L5_argtuple_error;
       }
     }
     __pyx_v_real = ((PyArrayObject *)values[0]);
     if (values[1]) {
-      __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 4996, __pyx_L3_error)
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 4389, __pyx_L3_error)
     } else {
-      __pyx_v_timeperiod = ((int)-2147483648);
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
     }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_TRIX", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 4996, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_ROC", 0, 1, 2, __pyx_nargs); __PYX_ERR(5, 4387, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_TRIX", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_ROC", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 4996, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_658stream_TRIX(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 4389, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_624stream_ROC(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_658stream_TRIX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_624stream_ROC(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
   double *__pyx_v_real_data;
@@ -61258,28 +76067,31 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_658stream_TRIX(CYTHON_UNUSED PyObject
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  __Pyx_RefNannySetupContext("stream_TRIX", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_ROC", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5015, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4408, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_real_data = ((double *)__pyx_v_real->data);
+  __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real));
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
   __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
 
-  __pyx_v_retCode = TA_TRIX((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
+  __pyx_v_retCode = TA_ROC((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_TRIX, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5020, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_ROC, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4413, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5021, __pyx_L1_error)
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4414, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -61289,7 +76101,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_658stream_TRIX(CYTHON_UNUSED PyObject
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_TRIX", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_ROC", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_real);
@@ -61300,81 +76112,119 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_658stream_TRIX(CYTHON_UNUSED PyObject
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_661stream_TSF(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_660stream_TSF[] = " TSF(real[, timeperiod=?])\n\n    Time Series Forecast (Statistic Functions)\n\n    Inputs:\n        real: (any ndarray)\n    Parameters:\n        timeperiod: 14\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_661stream_TSF = {"stream_TSF", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_661stream_TSF, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_660stream_TSF};
-static PyObject *__pyx_pw_5talib_7_ta_lib_661stream_TSF(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_627stream_ROCP(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_626stream_ROCP, "stream_ROCP(ndarray real, int timeperiod=-0x80000000)\n\nROCP(real[, timeperiod=?])\n\nRate of change Percentage: (real-prevPrice)/prevPrice (Momentum Indicators)\n\nInputs:\n    real: (any ndarray)\nParameters:\n    timeperiod: 10\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_627stream_ROCP = {"stream_ROCP", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_627stream_ROCP, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_626stream_ROCP};
+static PyObject *__pyx_pw_5talib_7_ta_lib_627stream_ROCP(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_real = 0;
   int __pyx_v_timeperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_TSF (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_ROCP (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,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);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 4416, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4416, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4416, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod);
-          if (value) { values[1] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_TSF") < 0)) __PYX_ERR(3, 5025, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_ROCP", 0) < (0)) __PYX_ERR(5, 4416, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_ROCP", 0, 1, 2, i); __PYX_ERR(5, 4416, __pyx_L3_error) }
       }
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4416, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4416, __pyx_L3_error)
         break;
         default: goto __pyx_L5_argtuple_error;
       }
     }
     __pyx_v_real = ((PyArrayObject *)values[0]);
     if (values[1]) {
-      __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 5025, __pyx_L3_error)
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 4418, __pyx_L3_error)
     } else {
-      __pyx_v_timeperiod = ((int)-2147483648);
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
     }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_TSF", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 5025, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_ROCP", 0, 1, 2, __pyx_nargs); __PYX_ERR(5, 4416, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_TSF", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_ROCP", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 5025, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_660stream_TSF(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 4418, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_626stream_ROCP(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_660stream_TSF(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_626stream_ROCP(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
   double *__pyx_v_real_data;
@@ -61384,28 +76234,31 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_660stream_TSF(CYTHON_UNUSED PyObject *
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  __Pyx_RefNannySetupContext("stream_TSF", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_ROCP", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5044, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4437, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_real_data = ((double *)__pyx_v_real->data);
+  __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real));
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
   __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
 
-  __pyx_v_retCode = TA_TSF((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
+  __pyx_v_retCode = TA_ROCP((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_TSF, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5049, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_ROCP, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4442, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5050, __pyx_L1_error)
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4443, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -61415,7 +76268,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_660stream_TSF(CYTHON_UNUSED PyObject *
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_TSF", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_ROCP", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_real);
@@ -61426,138 +76279,153 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_660stream_TSF(CYTHON_UNUSED PyObject *
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_663stream_TYPPRICE(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_662stream_TYPPRICE[] = " TYPPRICE(high, low, close)\n\n    Typical Price (Price Transform)\n\n    Inputs:\n        prices: ['high', 'low', 'close']\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_663stream_TYPPRICE = {"stream_TYPPRICE", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_663stream_TYPPRICE, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_662stream_TYPPRICE};
-static PyObject *__pyx_pw_5talib_7_ta_lib_663stream_TYPPRICE(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_high = 0;
-  PyArrayObject *__pyx_v_low = 0;
-  PyArrayObject *__pyx_v_close = 0;
+static PyObject *__pyx_pw_5talib_7_ta_lib_629stream_ROCR(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_628stream_ROCR, "stream_ROCR(ndarray real, int timeperiod=-0x80000000)\n\nROCR(real[, timeperiod=?])\n\nRate of change ratio: (real/prevPrice) (Momentum Indicators)\n\nInputs:\n    real: (any ndarray)\nParameters:\n    timeperiod: 10\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_629stream_ROCR = {"stream_ROCR", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_629stream_ROCR, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_628stream_ROCR};
+static PyObject *__pyx_pw_5talib_7_ta_lib_629stream_ROCR(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_real = 0;
+  int __pyx_v_timeperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_TYPPRICE (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_ROCR (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,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);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 4445, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4445, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4445, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_ROCR", 0) < (0)) __PYX_ERR(5, 4445, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_ROCR", 0, 1, 2, i); __PYX_ERR(5, 4445, __pyx_L3_error) }
+      }
+    } else {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4445, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_TYPPRICE", 1, 3, 3, 1); __PYX_ERR(3, 5054, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_TYPPRICE", 1, 3, 3, 2); __PYX_ERR(3, 5054, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_TYPPRICE") < 0)) __PYX_ERR(3, 5054, __pyx_L3_error)
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4445, __pyx_L3_error)
+        break;
+        default: goto __pyx_L5_argtuple_error;
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 3) {
-      goto __pyx_L5_argtuple_error;
+    }
+    __pyx_v_real = ((PyArrayObject *)values[0]);
+    if (values[1]) {
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 4447, __pyx_L3_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_timeperiod = ((int)((int)-2147483648));
     }
-    __pyx_v_high = ((PyArrayObject *)values[0]);
-    __pyx_v_low = ((PyArrayObject *)values[1]);
-    __pyx_v_close = ((PyArrayObject *)values[2]);
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_TYPPRICE", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 5054, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_ROCR", 0, 1, 2, __pyx_nargs); __PYX_ERR(5, 4445, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_TYPPRICE", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_ROCR", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 5054, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 5054, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 5054, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_662stream_TYPPRICE(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 4447, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_628stream_ROCR(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_662stream_TYPPRICE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_628stream_ROCR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
-  double *__pyx_v_high_data;
-  double *__pyx_v_low_data;
-  double *__pyx_v_close_data;
+  double *__pyx_v_real_data;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
   double __pyx_v_outreal;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  npy_intp __pyx_t_2;
-  __Pyx_RefNannySetupContext("stream_TYPPRICE", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_high);
-  __Pyx_INCREF((PyObject *)__pyx_v_low);
-  __Pyx_INCREF((PyObject *)__pyx_v_close);
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5073, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_v_high_data = ((double *)__pyx_v_high->data);
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5075, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_v_low_data = ((double *)__pyx_v_low->data);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_ROCR", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5077, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4466, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_close_data = ((double *)__pyx_v_close->data);
+  __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real));
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(3, 5079, __pyx_L1_error)
-  __pyx_v_length = __pyx_t_2;
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
   __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
 
-  __pyx_v_retCode = TA_TYPPRICE((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
+  __pyx_v_retCode = TA_ROCR((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_TYPPRICE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5082, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_ROCR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4471, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5083, __pyx_L1_error)
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4472, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -61567,12 +76435,10 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_662stream_TYPPRICE(CYTHON_UNUSED PyObj
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_TYPPRICE", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_ROCR", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_high);
-  __Pyx_XDECREF((PyObject *)__pyx_v_low);
-  __Pyx_XDECREF((PyObject *)__pyx_v_close);
+  __Pyx_XDECREF((PyObject *)__pyx_v_real);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -61580,188 +76446,153 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_662stream_TYPPRICE(CYTHON_UNUSED PyObj
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_665stream_ULTOSC(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_664stream_ULTOSC[] = " ULTOSC(high, low, close[, timeperiod1=?, timeperiod2=?, timeperiod3=?])\n\n    Ultimate Oscillator (Momentum Indicators)\n\n    Inputs:\n        prices: ['high', 'low', 'close']\n    Parameters:\n        timeperiod1: 7\n        timeperiod2: 14\n        timeperiod3: 28\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_665stream_ULTOSC = {"stream_ULTOSC", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_665stream_ULTOSC, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_664stream_ULTOSC};
-static PyObject *__pyx_pw_5talib_7_ta_lib_665stream_ULTOSC(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_high = 0;
-  PyArrayObject *__pyx_v_low = 0;
-  PyArrayObject *__pyx_v_close = 0;
-  int __pyx_v_timeperiod1;
-  int __pyx_v_timeperiod2;
-  int __pyx_v_timeperiod3;
+static PyObject *__pyx_pw_5talib_7_ta_lib_631stream_ROCR100(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_630stream_ROCR100, "stream_ROCR100(ndarray real, int timeperiod=-0x80000000)\n\nROCR100(real[, timeperiod=?])\n\nRate of change ratio 100 scale: (real/prevPrice)*100 (Momentum Indicators)\n\nInputs:\n    real: (any ndarray)\nParameters:\n    timeperiod: 10\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_631stream_ROCR100 = {"stream_ROCR100", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_631stream_ROCR100, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_630stream_ROCR100};
+static PyObject *__pyx_pw_5talib_7_ta_lib_631stream_ROCR100(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_real = 0;
+  int __pyx_v_timeperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_ULTOSC (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_ROCR100 (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,&__pyx_n_s_timeperiod1,&__pyx_n_s_timeperiod2,&__pyx_n_s_timeperiod3,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);
-        CYTHON_FALLTHROUGH;
-        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
-        CYTHON_FALLTHROUGH;
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 4474, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4474, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4474, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_ULTOSC", 0, 3, 6, 1); __PYX_ERR(3, 5087, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_ULTOSC", 0, 3, 6, 2); __PYX_ERR(3, 5087, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod1);
-          if (value) { values[3] = value; kw_args--; }
-        }
-        CYTHON_FALLTHROUGH;
-        case  4:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod2);
-          if (value) { values[4] = value; kw_args--; }
-        }
-        CYTHON_FALLTHROUGH;
-        case  5:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod3);
-          if (value) { values[5] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_ULTOSC") < 0)) __PYX_ERR(3, 5087, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_ROCR100", 0) < (0)) __PYX_ERR(5, 4474, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_ROCR100", 0, 1, 2, i); __PYX_ERR(5, 4474, __pyx_L3_error) }
       }
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
-        CYTHON_FALLTHROUGH;
-        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
-        CYTHON_FALLTHROUGH;
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4474, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4474, __pyx_L3_error)
         break;
         default: goto __pyx_L5_argtuple_error;
       }
     }
-    __pyx_v_high = ((PyArrayObject *)values[0]);
-    __pyx_v_low = ((PyArrayObject *)values[1]);
-    __pyx_v_close = ((PyArrayObject *)values[2]);
-    if (values[3]) {
-      __pyx_v_timeperiod1 = __Pyx_PyInt_As_int(values[3]); if (unlikely((__pyx_v_timeperiod1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 5087, __pyx_L3_error)
-    } else {
-      __pyx_v_timeperiod1 = ((int)-2147483648);
-    }
-    if (values[4]) {
-      __pyx_v_timeperiod2 = __Pyx_PyInt_As_int(values[4]); if (unlikely((__pyx_v_timeperiod2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 5087, __pyx_L3_error)
-    } else {
-      __pyx_v_timeperiod2 = ((int)-2147483648);
-    }
-    if (values[5]) {
-      __pyx_v_timeperiod3 = __Pyx_PyInt_As_int(values[5]); if (unlikely((__pyx_v_timeperiod3 == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 5087, __pyx_L3_error)
+    __pyx_v_real = ((PyArrayObject *)values[0]);
+    if (values[1]) {
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 4476, __pyx_L3_error)
     } else {
-      __pyx_v_timeperiod3 = ((int)-2147483648);
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
     }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_ULTOSC", 0, 3, 6, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 5087, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_ROCR100", 0, 1, 2, __pyx_nargs); __PYX_ERR(5, 4474, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_ULTOSC", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_ROCR100", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 5087, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 5087, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 5087, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_664stream_ULTOSC(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_timeperiod1, __pyx_v_timeperiod2, __pyx_v_timeperiod3);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 4476, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_630stream_ROCR100(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_664stream_ULTOSC(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod1, int __pyx_v_timeperiod2, int __pyx_v_timeperiod3) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_630stream_ROCR100(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
-  double *__pyx_v_high_data;
-  double *__pyx_v_low_data;
-  double *__pyx_v_close_data;
+  double *__pyx_v_real_data;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
   double __pyx_v_outreal;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  npy_intp __pyx_t_2;
-  __Pyx_RefNannySetupContext("stream_ULTOSC", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_high);
-  __Pyx_INCREF((PyObject *)__pyx_v_low);
-  __Pyx_INCREF((PyObject *)__pyx_v_close);
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5110, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_v_high_data = ((double *)__pyx_v_high->data);
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5112, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_v_low_data = ((double *)__pyx_v_low->data);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_ROCR100", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5114, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4495, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
+  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_close_data = ((double *)__pyx_v_close->data);
+  __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real));
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(3, 5116, __pyx_L1_error)
-  __pyx_v_length = __pyx_t_2;
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
   __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
 
-  __pyx_v_retCode = TA_ULTOSC((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, __pyx_v_timeperiod1, __pyx_v_timeperiod2, __pyx_v_timeperiod3, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
+  __pyx_v_retCode = TA_ROCR100((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_ULTOSC, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5119, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_ROCR100, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4500, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5120, __pyx_L1_error)
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4501, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -61771,12 +76602,10 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_664stream_ULTOSC(CYTHON_UNUSED PyObjec
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_ULTOSC", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_ROCR100", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_high);
-  __Pyx_XDECREF((PyObject *)__pyx_v_low);
-  __Pyx_XDECREF((PyObject *)__pyx_v_close);
+  __Pyx_XDECREF((PyObject *)__pyx_v_real);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -61784,97 +76613,119 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_664stream_ULTOSC(CYTHON_UNUSED PyObjec
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_667stream_VAR(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_666stream_VAR[] = " VAR(real[, timeperiod=?, nbdev=?])\n\n    Variance (Statistic Functions)\n\n    Inputs:\n        real: (any ndarray)\n    Parameters:\n        timeperiod: 5\n        nbdev: 1\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_667stream_VAR = {"stream_VAR", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_667stream_VAR, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_666stream_VAR};
-static PyObject *__pyx_pw_5talib_7_ta_lib_667stream_VAR(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_633stream_RSI(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_632stream_RSI, "stream_RSI(ndarray real, int timeperiod=-0x80000000)\n\nRSI(real[, timeperiod=?])\n\nRelative Strength Index (Momentum Indicators)\n\nInputs:\n    real: (any ndarray)\nParameters:\n    timeperiod: 14\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_633stream_RSI = {"stream_RSI", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_633stream_RSI, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_632stream_RSI};
+static PyObject *__pyx_pw_5talib_7_ta_lib_633stream_RSI(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_real = 0;
   int __pyx_v_timeperiod;
-  double __pyx_v_nbdev;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_VAR (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_RSI (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,&__pyx_n_s_nbdev,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);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 4503, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4503, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4503, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod);
-          if (value) { values[1] = value; kw_args--; }
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_nbdev);
-          if (value) { values[2] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_VAR") < 0)) __PYX_ERR(3, 5124, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_RSI", 0) < (0)) __PYX_ERR(5, 4503, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_RSI", 0, 1, 2, i); __PYX_ERR(5, 4503, __pyx_L3_error) }
       }
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4503, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4503, __pyx_L3_error)
         break;
         default: goto __pyx_L5_argtuple_error;
       }
     }
     __pyx_v_real = ((PyArrayObject *)values[0]);
     if (values[1]) {
-      __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 5124, __pyx_L3_error)
-    } else {
-      __pyx_v_timeperiod = ((int)-2147483648);
-    }
-    if (values[2]) {
-      __pyx_v_nbdev = __pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_nbdev == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 5124, __pyx_L3_error)
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 4505, __pyx_L3_error)
     } else {
-      __pyx_v_nbdev = ((double)-4e37);
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
     }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_VAR", 0, 1, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 5124, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_RSI", 0, 1, 2, __pyx_nargs); __PYX_ERR(5, 4503, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_VAR", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_RSI", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 5124, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_666stream_VAR(__pyx_self, __pyx_v_real, __pyx_v_timeperiod, __pyx_v_nbdev);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 4505, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_632stream_RSI(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_666stream_VAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod, double __pyx_v_nbdev) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_632stream_RSI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
   double *__pyx_v_real_data;
@@ -61884,28 +76735,31 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_666stream_VAR(CYTHON_UNUSED PyObject *
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  __Pyx_RefNannySetupContext("stream_VAR", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_RSI", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5144, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4524, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_real_data = ((double *)__pyx_v_real->data);
+  __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real));
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
   __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
 
-  __pyx_v_retCode = TA_VAR((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, __pyx_v_nbdev, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
+  __pyx_v_retCode = TA_RSI((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_VAR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5149, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_RSI, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4529, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5150, __pyx_L1_error)
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4530, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -61915,7 +76769,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_666stream_VAR(CYTHON_UNUSED PyObject *
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_VAR", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_RSI", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_real);
@@ -61926,92 +76780,146 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_666stream_VAR(CYTHON_UNUSED PyObject *
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_669stream_WCLPRICE(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_668stream_WCLPRICE[] = " WCLPRICE(high, low, close)\n\n    Weighted Close Price (Price Transform)\n\n    Inputs:\n        prices: ['high', 'low', 'close']\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_669stream_WCLPRICE = {"stream_WCLPRICE", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_669stream_WCLPRICE, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_668stream_WCLPRICE};
-static PyObject *__pyx_pw_5talib_7_ta_lib_669stream_WCLPRICE(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_635stream_SAR(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_634stream_SAR, "stream_SAR(ndarray high, ndarray low, double acceleration=0.02, double maximum=0.2)\n\nSAR(high, low[, acceleration=?, maximum=?])\n\nParabolic SAR (Overlap Studies)\n\nInputs:\n    prices: ['high', 'low']\nParameters:\n    acceleration: 0.02\n    maximum: 0.2\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_635stream_SAR = {"stream_SAR", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_635stream_SAR, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_634stream_SAR};
+static PyObject *__pyx_pw_5talib_7_ta_lib_635stream_SAR(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
-  PyArrayObject *__pyx_v_close = 0;
+  double __pyx_v_acceleration;
+  double __pyx_v_maximum;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_WCLPRICE (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_SAR (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,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);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_acceleration,&__pyx_mstate_global->__pyx_n_u_maximum,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 4532, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 4532, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 4532, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4532, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4532, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_SAR", 0) < (0)) __PYX_ERR(5, 4532, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_SAR", 0, 2, 4, i); __PYX_ERR(5, 4532, __pyx_L3_error) }
+      }
+    } else {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 4532, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_WCLPRICE", 1, 3, 3, 1); __PYX_ERR(3, 5154, __pyx_L3_error)
-        }
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 4532, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_WCLPRICE", 1, 3, 3, 2); __PYX_ERR(3, 5154, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_WCLPRICE") < 0)) __PYX_ERR(3, 5154, __pyx_L3_error)
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4532, __pyx_L3_error)
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4532, __pyx_L3_error)
+        break;
+        default: goto __pyx_L5_argtuple_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_high = ((PyArrayObject *)values[0]);
     __pyx_v_low = ((PyArrayObject *)values[1]);
-    __pyx_v_close = ((PyArrayObject *)values[2]);
+    if (values[2]) {
+      __pyx_v_acceleration = __Pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_acceleration == (double)-1) && PyErr_Occurred())) __PYX_ERR(5, 4534, __pyx_L3_error)
+    } else {
+      __pyx_v_acceleration = ((double)((double)0.02));
+    }
+    if (values[3]) {
+      __pyx_v_maximum = __Pyx_PyFloat_AsDouble(values[3]); if (unlikely((__pyx_v_maximum == (double)-1) && PyErr_Occurred())) __PYX_ERR(5, 4534, __pyx_L3_error)
+    } else {
+      __pyx_v_maximum = ((double)((double)0.2));
+    }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_WCLPRICE", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 5154, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_SAR", 0, 2, 4, __pyx_nargs); __PYX_ERR(5, 4532, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_WCLPRICE", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_SAR", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 5154, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 5154, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 5154, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_668stream_WCLPRICE(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 4534, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 4534, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_634stream_SAR(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_acceleration, __pyx_v_maximum);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_668stream_WCLPRICE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_634stream_SAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, double __pyx_v_acceleration, double __pyx_v_maximum) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
   double *__pyx_v_high_data;
   double *__pyx_v_low_data;
-  double *__pyx_v_close_data;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
   double __pyx_v_outreal;
@@ -62019,45 +76927,40 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_668stream_WCLPRICE(CYTHON_UNUSED PyObj
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
-  __Pyx_RefNannySetupContext("stream_WCLPRICE", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_SAR", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
-  __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5173, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4555, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_high_data = ((double *)__pyx_v_high->data);
+  __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5175, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4557, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_low_data = ((double *)__pyx_v_low->data);
-
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5177, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_v_close_data = ((double *)__pyx_v_close->data);
+  __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low));
 
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(3, 5179, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_high, __pyx_v_low); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 4559, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
   __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
 
-  __pyx_v_retCode = TA_WCLPRICE((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
+  __pyx_v_retCode = TA_SAR((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_high_data, __pyx_v_low_data, __pyx_v_acceleration, __pyx_v_maximum, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_WCLPRICE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5182, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_SAR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4562, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5183, __pyx_L1_error)
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4563, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -62067,12 +76970,11 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_668stream_WCLPRICE(CYTHON_UNUSED PyObj
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_WCLPRICE", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_SAR", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_high);
   __Pyx_XDECREF((PyObject *)__pyx_v_low);
-  __Pyx_XDECREF((PyObject *)__pyx_v_close);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -62080,110 +76982,230 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_668stream_WCLPRICE(CYTHON_UNUSED PyObj
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_671stream_WILLR(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_670stream_WILLR[] = " WILLR(high, low, close[, timeperiod=?])\n\n    Williams' %R (Momentum Indicators)\n\n    Inputs:\n        prices: ['high', 'low', 'close']\n    Parameters:\n        timeperiod: 14\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_671stream_WILLR = {"stream_WILLR", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_671stream_WILLR, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_670stream_WILLR};
-static PyObject *__pyx_pw_5talib_7_ta_lib_671stream_WILLR(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_637stream_SAREXT(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_636stream_SAREXT, "stream_SAREXT(ndarray high, ndarray low, double startvalue=-4e37, double offsetonreverse=-4e37, double accelerationinitlong=-4e37, double accelerationlong=-4e37, double accelerationmaxlong=-4e37, double accelerationinitshort=-4e37, double accelerationshort=-4e37, double accelerationmaxshort=-4e37)\n\nSAREXT(high, low[, startvalue=?, offsetonreverse=?, accelerationinitlong=?, accelerationlong=?, accelerationmaxlong=?, accelerationinitshort=?, accelerationshort=?, accelerationmaxshort=?])\n\nParabolic SAR - Extended (Overlap Studies)\n\nInputs:\n    prices: ['high', 'low']\nParameters:\n    startvalue: 0.0\n    offsetonreverse: 0.0\n    accelerationinitlong: 0.02\n    accelerationlong: 0.02\n    accelerationmaxlong: 0.2\n    accelerationinitshort: 0.02\n    accelerationshort: 0.02\n    accelerationmaxshort: 0.2\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_637stream_SAREXT = {"stream_SAREXT", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_637stream_SAREXT, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_636stream_SAREXT};
+static PyObject *__pyx_pw_5talib_7_ta_lib_637stream_SAREXT(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_high = 0;
   PyArrayObject *__pyx_v_low = 0;
-  PyArrayObject *__pyx_v_close = 0;
-  int __pyx_v_timeperiod;
+  double __pyx_v_startvalue;
+  double __pyx_v_offsetonreverse;
+  double __pyx_v_accelerationinitlong;
+  double __pyx_v_accelerationlong;
+  double __pyx_v_accelerationmaxlong;
+  double __pyx_v_accelerationinitshort;
+  double __pyx_v_accelerationshort;
+  double __pyx_v_accelerationmaxshort;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[10] = {0,0,0,0,0,0,0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_WILLR (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_SAREXT (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_high,&__pyx_n_s_low,&__pyx_n_s_close,&__pyx_n_s_timeperiod,0};
-    PyObject* values[4] = {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  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_startvalue,&__pyx_mstate_global->__pyx_n_u_offsetonreverse,&__pyx_mstate_global->__pyx_n_u_accelerationinitlong,&__pyx_mstate_global->__pyx_n_u_accelerationlong,&__pyx_mstate_global->__pyx_n_u_accelerationmaxlong,&__pyx_mstate_global->__pyx_n_u_accelerationinitshort,&__pyx_mstate_global->__pyx_n_u_accelerationshort,&__pyx_mstate_global->__pyx_n_u_accelerationmaxshort,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 4565, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case 10:
+        values[9] = __Pyx_ArgRef_FASTCALL(__pyx_args, 9);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[9])) __PYX_ERR(5, 4565, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  9:
+        values[8] = __Pyx_ArgRef_FASTCALL(__pyx_args, 8);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[8])) __PYX_ERR(5, 4565, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  8:
+        values[7] = __Pyx_ArgRef_FASTCALL(__pyx_args, 7);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[7])) __PYX_ERR(5, 4565, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  7:
+        values[6] = __Pyx_ArgRef_FASTCALL(__pyx_args, 6);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(5, 4565, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  0: break;
-        default: goto __pyx_L5_argtuple_error;
-      }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_high)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
+        case  6:
+        values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(5, 4565, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_low)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_WILLR", 0, 3, 4, 1); __PYX_ERR(3, 5187, __pyx_L3_error)
-        }
+        case  5:
+        values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(5, 4565, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_close)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("stream_WILLR", 0, 3, 4, 2); __PYX_ERR(3, 5187, __pyx_L3_error)
-        }
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 4565, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  3:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod);
-          if (value) { values[3] = value; kw_args--; }
-        }
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 4565, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4565, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4565, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
       }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_WILLR") < 0)) __PYX_ERR(3, 5187, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_SAREXT", 0) < (0)) __PYX_ERR(5, 4565, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_SAREXT", 0, 2, 10, i); __PYX_ERR(5, 4565, __pyx_L3_error) }
       }
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+      switch (__pyx_nargs) {
+        case 10:
+        values[9] = __Pyx_ArgRef_FASTCALL(__pyx_args, 9);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[9])) __PYX_ERR(5, 4565, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  9:
+        values[8] = __Pyx_ArgRef_FASTCALL(__pyx_args, 8);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[8])) __PYX_ERR(5, 4565, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  8:
+        values[7] = __Pyx_ArgRef_FASTCALL(__pyx_args, 7);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[7])) __PYX_ERR(5, 4565, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  7:
+        values[6] = __Pyx_ArgRef_FASTCALL(__pyx_args, 6);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(5, 4565, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  6:
+        values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(5, 4565, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  5:
+        values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(5, 4565, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 4565, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 4565, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4565, __pyx_L3_error)
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4565, __pyx_L3_error)
         break;
         default: goto __pyx_L5_argtuple_error;
       }
     }
     __pyx_v_high = ((PyArrayObject *)values[0]);
     __pyx_v_low = ((PyArrayObject *)values[1]);
-    __pyx_v_close = ((PyArrayObject *)values[2]);
+    if (values[2]) {
+      __pyx_v_startvalue = __Pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_startvalue == (double)-1) && PyErr_Occurred())) __PYX_ERR(5, 4567, __pyx_L3_error)
+    } else {
+      __pyx_v_startvalue = ((double)((double)-4e37));
+    }
     if (values[3]) {
-      __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[3]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 5187, __pyx_L3_error)
+      __pyx_v_offsetonreverse = __Pyx_PyFloat_AsDouble(values[3]); if (unlikely((__pyx_v_offsetonreverse == (double)-1) && PyErr_Occurred())) __PYX_ERR(5, 4567, __pyx_L3_error)
+    } else {
+      __pyx_v_offsetonreverse = ((double)((double)-4e37));
+    }
+    if (values[4]) {
+      __pyx_v_accelerationinitlong = __Pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_accelerationinitlong == (double)-1) && PyErr_Occurred())) __PYX_ERR(5, 4567, __pyx_L3_error)
+    } else {
+      __pyx_v_accelerationinitlong = ((double)((double)-4e37));
+    }
+    if (values[5]) {
+      __pyx_v_accelerationlong = __Pyx_PyFloat_AsDouble(values[5]); if (unlikely((__pyx_v_accelerationlong == (double)-1) && PyErr_Occurred())) __PYX_ERR(5, 4567, __pyx_L3_error)
+    } else {
+      __pyx_v_accelerationlong = ((double)((double)-4e37));
+    }
+    if (values[6]) {
+      __pyx_v_accelerationmaxlong = __Pyx_PyFloat_AsDouble(values[6]); if (unlikely((__pyx_v_accelerationmaxlong == (double)-1) && PyErr_Occurred())) __PYX_ERR(5, 4567, __pyx_L3_error)
+    } else {
+      __pyx_v_accelerationmaxlong = ((double)((double)-4e37));
+    }
+    if (values[7]) {
+      __pyx_v_accelerationinitshort = __Pyx_PyFloat_AsDouble(values[7]); if (unlikely((__pyx_v_accelerationinitshort == (double)-1) && PyErr_Occurred())) __PYX_ERR(5, 4567, __pyx_L3_error)
+    } else {
+      __pyx_v_accelerationinitshort = ((double)((double)-4e37));
+    }
+    if (values[8]) {
+      __pyx_v_accelerationshort = __Pyx_PyFloat_AsDouble(values[8]); if (unlikely((__pyx_v_accelerationshort == (double)-1) && PyErr_Occurred())) __PYX_ERR(5, 4567, __pyx_L3_error)
+    } else {
+      __pyx_v_accelerationshort = ((double)((double)-4e37));
+    }
+    if (values[9]) {
+      __pyx_v_accelerationmaxshort = __Pyx_PyFloat_AsDouble(values[9]); if (unlikely((__pyx_v_accelerationmaxshort == (double)-1) && PyErr_Occurred())) __PYX_ERR(5, 4567, __pyx_L3_error)
     } else {
-      __pyx_v_timeperiod = ((int)-2147483648);
+      __pyx_v_accelerationmaxshort = ((double)((double)-4e37));
     }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_WILLR", 0, 3, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 5187, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_SAREXT", 0, 2, 10, __pyx_nargs); __PYX_ERR(5, 4565, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_WILLR", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_SAREXT", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(3, 5187, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(3, 5187, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(3, 5187, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_670stream_WILLR(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_timeperiod);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 4567, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 4567, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_636stream_SAREXT(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_startvalue, __pyx_v_offsetonreverse, __pyx_v_accelerationinitlong, __pyx_v_accelerationlong, __pyx_v_accelerationmaxlong, __pyx_v_accelerationinitshort, __pyx_v_accelerationshort, __pyx_v_accelerationmaxshort);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_670stream_WILLR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_636stream_SAREXT(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, double __pyx_v_startvalue, double __pyx_v_offsetonreverse, double __pyx_v_accelerationinitlong, double __pyx_v_accelerationlong, double __pyx_v_accelerationmaxlong, double __pyx_v_accelerationinitshort, double __pyx_v_accelerationshort, double __pyx_v_accelerationmaxshort) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
   double *__pyx_v_high_data;
   double *__pyx_v_low_data;
-  double *__pyx_v_close_data;
   int __pyx_v_outbegidx;
   int __pyx_v_outnbelement;
   double __pyx_v_outreal;
@@ -62191,45 +77213,40 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_670stream_WILLR(CYTHON_UNUSED PyObject
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
   npy_intp __pyx_t_2;
-  __Pyx_RefNannySetupContext("stream_WILLR", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_SAREXT", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_high);
   __Pyx_INCREF((PyObject *)__pyx_v_low);
-  __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5208, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4594, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_high_data = ((double *)__pyx_v_high->data);
+  __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5210, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4596, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_low_data = ((double *)__pyx_v_low->data);
+  __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low));
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5212, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
-  __pyx_t_1 = 0;
-
-  __pyx_v_close_data = ((double *)__pyx_v_close->data);
-
-  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(3, 5214, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_high, __pyx_v_low); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 4598, __pyx_L1_error)
   __pyx_v_length = __pyx_t_2;
 
   __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
 
-  __pyx_v_retCode = TA_WILLR((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
+  __pyx_v_retCode = TA_SAREXT((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_high_data, __pyx_v_low_data, __pyx_v_startvalue, __pyx_v_offsetonreverse, __pyx_v_accelerationinitlong, __pyx_v_accelerationlong, __pyx_v_accelerationmaxlong, __pyx_v_accelerationinitshort, __pyx_v_accelerationshort, __pyx_v_accelerationmaxshort, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_WILLR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5217, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_SAREXT, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4601, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5218, __pyx_L1_error)
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4602, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -62239,12 +77256,11 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_670stream_WILLR(CYTHON_UNUSED PyObject
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_WILLR", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_SAREXT", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_high);
   __Pyx_XDECREF((PyObject *)__pyx_v_low);
-  __Pyx_XDECREF((PyObject *)__pyx_v_close);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
@@ -62252,81 +77268,102 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_670stream_WILLR(CYTHON_UNUSED PyObject
 
 
 /* Python wrapper */
-static PyObject *__pyx_pw_5talib_7_ta_lib_673stream_WMA(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_5talib_7_ta_lib_672stream_WMA[] = " WMA(real[, timeperiod=?])\n\n    Weighted Moving Average (Overlap Studies)\n\n    Inputs:\n        real: (any ndarray)\n    Parameters:\n        timeperiod: 30\n    Outputs:\n        real\n    ";
-static PyMethodDef __pyx_mdef_5talib_7_ta_lib_673stream_WMA = {"stream_WMA", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_673stream_WMA, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_672stream_WMA};
-static PyObject *__pyx_pw_5talib_7_ta_lib_673stream_WMA(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_5talib_7_ta_lib_639stream_SIN(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_638stream_SIN, "stream_SIN(ndarray real)\n\nSIN(real)\n\nVector Trigonometric Sin (Math Transform)\n\nInputs:\n    real: (any ndarray)\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_639stream_SIN = {"stream_SIN", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_639stream_SIN, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_638stream_SIN};
+static PyObject *__pyx_pw_5talib_7_ta_lib_639stream_SIN(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyArrayObject *__pyx_v_real = 0;
-  int __pyx_v_timeperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("stream_WMA (wrapper)", 0);
+  __Pyx_RefNannySetupContext("stream_SIN (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_real,&__pyx_n_s_timeperiod,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);
-        CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 4604, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4604, __pyx_L3_error)
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_real)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_timeperiod);
-          if (value) { values[1] = value; kw_args--; }
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stream_WMA") < 0)) __PYX_ERR(3, 5222, __pyx_L3_error)
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_SIN", 0) < (0)) __PYX_ERR(5, 4604, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_SIN", 1, 1, 1, i); __PYX_ERR(5, 4604, __pyx_L3_error) }
       }
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-        break;
-        default: goto __pyx_L5_argtuple_error;
-      }
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4604, __pyx_L3_error)
     }
     __pyx_v_real = ((PyArrayObject *)values[0]);
-    if (values[1]) {
-      __pyx_v_timeperiod = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 5222, __pyx_L3_error)
-    } else {
-      __pyx_v_timeperiod = ((int)-2147483648);
-    }
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("stream_WMA", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 5222, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("stream_SIN", 1, 1, 1, __pyx_nargs); __PYX_ERR(5, 4604, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
-  __Pyx_AddTraceback("talib._ta_lib.stream_WMA", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_SIN", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(3, 5222, __pyx_L1_error)
-  __pyx_r = __pyx_pf_5talib_7_ta_lib_672stream_WMA(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 4606, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_638stream_SIN(__pyx_self, __pyx_v_real);
 
   /* function exit code */
   goto __pyx_L0;
   __pyx_L1_error:;
   __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyObject *__pyx_pf_5talib_7_ta_lib_672stream_WMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_638stream_SIN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) {
   npy_intp __pyx_v_length;
   TA_RetCode __pyx_v_retCode;
   double *__pyx_v_real_data;
@@ -62336,28 +77373,31 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_672stream_WMA(CYTHON_UNUSED PyObject *
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  __Pyx_RefNannySetupContext("stream_WMA", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_SIN", 0);
   __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5241, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4623, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
 
-  __pyx_v_real_data = ((double *)__pyx_v_real->data);
+  __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real));
 
-  __pyx_v_length = (__pyx_v_real->dimensions[0]);
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
   __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
 
-  __pyx_v_retCode = TA_WMA((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
+  __pyx_v_retCode = TA_SIN((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
 
-  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_n_s_TA_WMA, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5246, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_SIN, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4628, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 5247, __pyx_L1_error)
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4629, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -62367,7 +77407,7 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_672stream_WMA(CYTHON_UNUSED PyObject *
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("talib._ta_lib.stream_WMA", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("talib._ta_lib.stream_SIN", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
   __Pyx_XDECREF((PyObject *)__pyx_v_real);
@@ -62378,410 +77418,136 @@ static PyObject *__pyx_pf_5talib_7_ta_lib_672stream_WMA(CYTHON_UNUSED PyObject *
 
 
 /* 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_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_r;
+static PyObject *__pyx_pw_5talib_7_ta_lib_641stream_SINH(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_640stream_SINH, "stream_SINH(ndarray real)\n\nSINH(real)\n\nVector Trigonometric Sinh (Math Transform)\n\nInputs:\n    real: (any ndarray)\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_641stream_SINH = {"stream_SINH", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_641stream_SINH, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_640stream_SINH};
+static PyObject *__pyx_pw_5talib_7_ta_lib_641stream_SINH(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_real = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  int __pyx_t_1;
-  int __pyx_t_2;
-  PyObject *__pyx_t_3 = NULL;
-  int __pyx_t_4;
-  int __pyx_t_5;
-  int __pyx_t_6;
-  PyArray_Descr *__pyx_t_7;
-  PyObject *__pyx_t_8 = NULL;
-  char *__pyx_t_9;
-  if (__pyx_v_info == NULL) {
-    PyErr_SetString(PyExc_BufferError, "PyObject_GetBuffer: view==NULL argument is obsolete");
-    return -1;
-  }
-  __Pyx_RefNannySetupContext("__getbuffer__", 0);
-  __pyx_v_info->obj = Py_None; __Pyx_INCREF(Py_None);
-  __Pyx_GIVEREF(__pyx_v_info->obj);
-
-  __pyx_v_endian_detector = 1;
-
-  __pyx_v_little_endian = ((((char *)(&__pyx_v_endian_detector))[0]) != 0);
-
-  __pyx_v_ndim = PyArray_NDIM(__pyx_v_self);
-
-  __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_L4_bool_binop_done;
-  }
-
-  __pyx_t_2 = ((!(PyArray_CHKFLAGS(__pyx_v_self, NPY_ARRAY_C_CONTIGUOUS) != 0)) != 0);
-  __pyx_t_1 = __pyx_t_2;
-  __pyx_L4_bool_binop_done:;
-
-  if (unlikely(__pyx_t_1)) {
-
-    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__12, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 272, __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(4, 272, __pyx_L1_error)
-
-  }
-
-  __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_L7_bool_binop_done;
-  }
-
-  __pyx_t_2 = ((!(PyArray_CHKFLAGS(__pyx_v_self, NPY_ARRAY_F_CONTIGUOUS) != 0)) != 0);
-  __pyx_t_1 = __pyx_t_2;
-  __pyx_L7_bool_binop_done:;
-
-  if (unlikely(__pyx_t_1)) {
-
-    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__13, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 276, __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(4, 276, __pyx_L1_error)
-
-  }
-
-  __pyx_v_info->buf = PyArray_DATA(__pyx_v_self);
-
-  __pyx_v_info->ndim = __pyx_v_ndim;
-
-  __pyx_t_1 = (((sizeof(npy_intp)) != (sizeof(Py_ssize_t))) != 0);
-  if (__pyx_t_1) {
-
-    __pyx_v_info->strides = ((Py_ssize_t *)PyObject_Malloc((((sizeof(Py_ssize_t)) * 2) * ((size_t)__pyx_v_ndim))));
-
-    __pyx_v_info->shape = (__pyx_v_info->strides + __pyx_v_ndim);
-
-    __pyx_t_4 = __pyx_v_ndim;
-    __pyx_t_5 = __pyx_t_4;
-    for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) {
-      __pyx_v_i = __pyx_t_6;
-
-      (__pyx_v_info->strides[__pyx_v_i]) = (PyArray_STRIDES(__pyx_v_self)[__pyx_v_i]);
-
-      (__pyx_v_info->shape[__pyx_v_i]) = (PyArray_DIMS(__pyx_v_self)[__pyx_v_i]);
-    }
-
-    goto __pyx_L9;
-  }
-
-  /*else*/ {
-    __pyx_v_info->strides = ((Py_ssize_t *)PyArray_STRIDES(__pyx_v_self));
-
-    __pyx_v_info->shape = ((Py_ssize_t *)PyArray_DIMS(__pyx_v_self));
-  }
-  __pyx_L9:;
-
-  __pyx_v_info->suboffsets = NULL;
-
-  __pyx_v_info->itemsize = PyArray_ITEMSIZE(__pyx_v_self);
-
-  __pyx_v_info->readonly = (!(PyArray_ISWRITEABLE(__pyx_v_self) != 0));
-
-  __pyx_v_f = NULL;
-
-  __pyx_t_7 = PyArray_DESCR(__pyx_v_self);
-  __pyx_t_3 = ((PyObject *)__pyx_t_7);
-  __Pyx_INCREF(__pyx_t_3);
-  __pyx_v_descr = ((PyArray_Descr *)__pyx_t_3);
-  __pyx_t_3 = 0;
-
-  __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_t_1 = ((!(PyDataType_HASFIELDS(__pyx_v_descr) != 0)) != 0);
-  if (__pyx_t_1) {
-
-    __pyx_t_4 = __pyx_v_descr->type_num;
-    __pyx_v_t = __pyx_t_4;
-
-    __pyx_t_2 = ((__pyx_v_descr->byteorder == '>') != 0);
-    if (!__pyx_t_2) {
-      goto __pyx_L15_next_or;
-    } else {
-    }
-    __pyx_t_2 = (__pyx_v_little_endian != 0);
-    if (!__pyx_t_2) {
-    } else {
-      __pyx_t_1 = __pyx_t_2;
-      goto __pyx_L14_bool_binop_done;
-    }
-    __pyx_L15_next_or:;
-
-    __pyx_t_2 = ((__pyx_v_descr->byteorder == '<') != 0);
-    if (__pyx_t_2) {
+  __Pyx_RefNannySetupContext("stream_SINH (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 4631, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4631, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_SINH", 0) < (0)) __PYX_ERR(5, 4631, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_SINH", 1, 1, 1, i); __PYX_ERR(5, 4631, __pyx_L3_error) }
+      }
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
     } else {
-      __pyx_t_1 = __pyx_t_2;
-      goto __pyx_L14_bool_binop_done;
-    }
-    __pyx_t_2 = ((!(__pyx_v_little_endian != 0)) != 0);
-    __pyx_t_1 = __pyx_t_2;
-    __pyx_L14_bool_binop_done:;
-
-    if (unlikely(__pyx_t_1)) {
-
-      __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__14, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 306, __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(4, 306, __pyx_L1_error)
-
-    }
-
-    switch (__pyx_v_t) {
-      case NPY_BYTE:
-      __pyx_v_f = ((char *)"b");
-      break;
-      case NPY_UBYTE:
-
-      __pyx_v_f = ((char *)"B");
-      break;
-      case NPY_SHORT:
-
-      __pyx_v_f = ((char *)"h");
-      break;
-      case NPY_USHORT:
-
-      __pyx_v_f = ((char *)"H");
-      break;
-      case NPY_INT:
-
-      __pyx_v_f = ((char *)"i");
-      break;
-      case NPY_UINT:
-
-      __pyx_v_f = ((char *)"I");
-      break;
-      case NPY_LONG:
-
-      __pyx_v_f = ((char *)"l");
-      break;
-      case NPY_ULONG:
-
-      __pyx_v_f = ((char *)"L");
-      break;
-      case NPY_LONGLONG:
-
-      __pyx_v_f = ((char *)"q");
-      break;
-      case NPY_ULONGLONG:
-
-      __pyx_v_f = ((char *)"Q");
-      break;
-      case NPY_FLOAT:
-
-      __pyx_v_f = ((char *)"f");
-      break;
-      case NPY_DOUBLE:
-
-      __pyx_v_f = ((char *)"d");
-      break;
-      case NPY_LONGDOUBLE:
-
-      __pyx_v_f = ((char *)"g");
-      break;
-      case NPY_CFLOAT:
-
-      __pyx_v_f = ((char *)"Zf");
-      break;
-      case NPY_CDOUBLE:
-
-      __pyx_v_f = ((char *)"Zd");
-      break;
-      case NPY_CLONGDOUBLE:
-
-      __pyx_v_f = ((char *)"Zg");
-      break;
-      case NPY_OBJECT:
-
-      __pyx_v_f = ((char *)"O");
-      break;
-      default:
-
-      __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_t); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 325, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_3);
-      __pyx_t_8 = PyUnicode_Format(__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(4, 325, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_8);
-      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-      __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 325, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_3);
-      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
-      __Pyx_Raise(__pyx_t_3, 0, 0, 0);
-      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-      __PYX_ERR(4, 325, __pyx_L1_error)
-      break;
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4631, __pyx_L3_error)
     }
-
-    __pyx_v_info->format = __pyx_v_f;
-
-    __pyx_r = 0;
-    goto __pyx_L0;
-
+    __pyx_v_real = ((PyArrayObject *)values[0]);
   }
-
-  /*else*/ {
-    __pyx_v_info->format = ((char *)PyObject_Malloc(0xFF));
-
-    (__pyx_v_info->format[0]) = '^';
-
-    __pyx_v_offset = 0;
-
-    __pyx_t_9 = __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_9 == ((char *)NULL))) __PYX_ERR(4, 332, __pyx_L1_error)
-    __pyx_v_f = __pyx_t_9;
-
-    (__pyx_v_f[0]) = '\x00';
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("stream_SINH", 1, 1, 1, __pyx_nargs); __PYX_ERR(5, 4631, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
   }
-
+  __Pyx_AddTraceback("talib._ta_lib.stream_SINH", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 4633, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_640stream_SINH(__pyx_self, __pyx_v_real);
 
   /* function exit code */
-  __pyx_r = 0;
   goto __pyx_L0;
   __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_3);
-  __Pyx_XDECREF(__pyx_t_8);
-  __Pyx_AddTraceback("numpy.ndarray.__getbuffer__", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = -1;
-  if (__pyx_v_info->obj != NULL) {
-    __Pyx_GOTREF(__pyx_v_info->obj);
-    __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0;
+  __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
   }
-  goto __pyx_L2;
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
-  if (__pyx_v_info->obj == Py_None) {
-    __Pyx_GOTREF(__pyx_v_info->obj);
-    __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
   }
-  __pyx_L2:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_descr);
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-
-/* 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);
-
-  __pyx_t_1 = (PyArray_HASFIELDS(__pyx_v_self) != 0);
-  if (__pyx_t_1) {
-
-    PyObject_Free(__pyx_v_info->format);
-
-  }
-
-  __pyx_t_1 = (((sizeof(npy_intp)) != (sizeof(Py_ssize_t))) != 0);
-  if (__pyx_t_1) {
-
-    PyObject_Free(__pyx_v_info->strides);
-
-  }
-
-
-  /* function exit code */
-  __Pyx_RefNannyFinishContext();
-}
-
-
-static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew1(PyObject *__pyx_v_a) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_640stream_SINH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) {
+  npy_intp __pyx_v_length;
+  TA_RetCode __pyx_v_retCode;
+  double *__pyx_v_real_data;
+  int __pyx_v_outbegidx;
+  int __pyx_v_outnbelement;
+  double __pyx_v_outreal;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  __Pyx_RefNannySetupContext("PyArray_MultiIterNew1", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_SINH", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyArray_MultiIterNew(1, ((void *)__pyx_v_a)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 822, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4650, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_r = __pyx_t_1;
+  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
   __pyx_t_1 = 0;
-  goto __pyx_L0;
 
+  __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real));
 
-  /* 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;
-}
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
+  __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
 
-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);
+  __pyx_v_retCode = TA_SINH((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
 
-  __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(4, 825, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_SINH, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4655, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_r = __pyx_t_1;
-  __pyx_t_1 = 0;
-  goto __pyx_L0;
-
-
-  /* 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;
-}
-
-
-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);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __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(4, 828, __pyx_L1_error)
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4656, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -62791,49 +77557,164 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew3(PyObject *__
   /* 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_AddTraceback("talib._ta_lib.stream_SINH", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
   __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_real);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
 
-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;
+/* Python wrapper */
+static PyObject *__pyx_pw_5talib_7_ta_lib_643stream_SMA(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_642stream_SMA, "stream_SMA(ndarray real, int timeperiod=-0x80000000)\n\nSMA(real[, timeperiod=?])\n\nSimple Moving Average (Overlap Studies)\n\nInputs:\n    real: (any ndarray)\nParameters:\n    timeperiod: 30\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_643stream_SMA = {"stream_SMA", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_643stream_SMA, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_642stream_SMA};
+static PyObject *__pyx_pw_5talib_7_ta_lib_643stream_SMA(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_real = 0;
+  int __pyx_v_timeperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
-  __Pyx_RefNannySetupContext("PyArray_MultiIterNew4", 0);
-
-  __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(4, 831, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_r = __pyx_t_1;
-  __pyx_t_1 = 0;
-  goto __pyx_L0;
-
+  __Pyx_RefNannySetupContext("stream_SMA (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 4658, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4658, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4658, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_SMA", 0) < (0)) __PYX_ERR(5, 4658, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_SMA", 0, 1, 2, i); __PYX_ERR(5, 4658, __pyx_L3_error) }
+      }
+    } else {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4658, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4658, __pyx_L3_error)
+        break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+    }
+    __pyx_v_real = ((PyArrayObject *)values[0]);
+    if (values[1]) {
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 4660, __pyx_L3_error)
+    } else {
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
+    }
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("stream_SMA", 0, 1, 2, __pyx_nargs); __PYX_ERR(5, 4658, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_SMA", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 4660, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_642stream_SMA(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
 
   /* function exit code */
+  goto __pyx_L0;
   __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_AddTraceback("numpy.PyArray_MultiIterNew4", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = 0;
+  __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
-  __Pyx_XGIVEREF(__pyx_r);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-
-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) {
+static PyObject *__pyx_pf_5talib_7_ta_lib_642stream_SMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
+  npy_intp __pyx_v_length;
+  TA_RetCode __pyx_v_retCode;
+  double *__pyx_v_real_data;
+  int __pyx_v_outbegidx;
+  int __pyx_v_outnbelement;
+  double __pyx_v_outreal;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  __Pyx_RefNannySetupContext("PyArray_MultiIterNew5", 0);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_SMA", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_real);
+
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4679, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
+
+  __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real));
+
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
+
+  __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
+
+  __pyx_v_retCode = TA_SMA((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
+
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_SMA, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4684, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __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(4, 834, __pyx_L1_error)
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4685, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
@@ -62843,7259 +77724,12556 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew5(PyObject *__
   /* 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_AddTraceback("talib._ta_lib.stream_SMA", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
   __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_real);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
 
-static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyDataType_SHAPE(PyArray_Descr *__pyx_v_d) {
-  PyObject *__pyx_r = NULL;
+/* Python wrapper */
+static PyObject *__pyx_pw_5talib_7_ta_lib_645stream_SQRT(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_644stream_SQRT, "stream_SQRT(ndarray real)\n\nSQRT(real)\n\nVector Square Root (Math Transform)\n\nInputs:\n    real: (any ndarray)\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_645stream_SQRT = {"stream_SQRT", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_645stream_SQRT, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_644stream_SQRT};
+static PyObject *__pyx_pw_5talib_7_ta_lib_645stream_SQRT(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_real = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  int __pyx_t_1;
-  __Pyx_RefNannySetupContext("PyDataType_SHAPE", 0);
-
-  __pyx_t_1 = (PyDataType_HASSUBARRAY(__pyx_v_d) != 0);
-  if (__pyx_t_1) {
-
-    __Pyx_XDECREF(__pyx_r);
-    __Pyx_INCREF(((PyObject*)__pyx_v_d->subarray->shape));
-    __pyx_r = ((PyObject*)__pyx_v_d->subarray->shape);
-    goto __pyx_L0;
-
+  __Pyx_RefNannySetupContext("stream_SQRT (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 4687, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4687, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_SQRT", 0) < (0)) __PYX_ERR(5, 4687, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_SQRT", 1, 1, 1, i); __PYX_ERR(5, 4687, __pyx_L3_error) }
+      }
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4687, __pyx_L3_error)
+    }
+    __pyx_v_real = ((PyArrayObject *)values[0]);
   }
-
-  /*else*/ {
-    __Pyx_XDECREF(__pyx_r);
-    __Pyx_INCREF(__pyx_empty_tuple);
-    __pyx_r = __pyx_empty_tuple;
-    goto __pyx_L0;
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("stream_SQRT", 1, 1, 1, __pyx_nargs); __PYX_ERR(5, 4687, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
   }
-
+  __Pyx_AddTraceback("talib._ta_lib.stream_SQRT", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 4689, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_644stream_SQRT(__pyx_self, __pyx_v_real);
 
   /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
-  __Pyx_XGIVEREF(__pyx_r);
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-
-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;
+static PyObject *__pyx_pf_5talib_7_ta_lib_644stream_SQRT(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) {
+  npy_intp __pyx_v_length;
+  TA_RetCode __pyx_v_retCode;
+  double *__pyx_v_real_data;
+  int __pyx_v_outbegidx;
+  int __pyx_v_outnbelement;
+  double __pyx_v_outreal;
+  PyObject *__pyx_r = NULL;
   __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);
-
-  __pyx_v_endian_detector = 1;
-
-  __pyx_v_little_endian = ((((char *)(&__pyx_v_endian_detector))[0]) != 0);
-
-  if (unlikely(__pyx_v_descr->names == Py_None)) {
-    PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable");
-    __PYX_ERR(4, 851, __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(4, 851, __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(4, 851, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_3);
-    #endif
-    __Pyx_XDECREF_SET(__pyx_v_childname, __pyx_t_3);
-    __pyx_t_3 = 0;
-
-    if (unlikely(__pyx_v_descr->fields == Py_None)) {
-      PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
-      __PYX_ERR(4, 852, __pyx_L1_error)
-    }
-    __pyx_t_3 = __Pyx_PyDict_GetItem(__pyx_v_descr->fields, __pyx_v_childname); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 852, __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(4, 852, __pyx_L1_error)
-    __Pyx_XDECREF_SET(__pyx_v_fields, ((PyObject*)__pyx_t_3));
-    __pyx_t_3 = 0;
-
-    if (likely(__pyx_v_fields != Py_None)) {
-      PyObject* sequence = __pyx_v_fields;
-      Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
-      if (unlikely(size != 2)) {
-        if (size > 2) __Pyx_RaiseTooManyValuesError(2);
-        else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
-        __PYX_ERR(4, 853, __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(4, 853, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_3);
-      __pyx_t_4 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 853, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_4);
-      #endif
-    } else {
-      __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(4, 853, __pyx_L1_error)
-    }
-    if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_5numpy_dtype))))) __PYX_ERR(4, 853, __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;
-
-    __pyx_t_4 = __Pyx_PyInt_From_int((__pyx_v_offset[0])); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 855, __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(4, 855, __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(4, 855, __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 (unlikely(__pyx_t_6)) {
-
-      __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__15, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 856, __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(4, 856, __pyx_L1_error)
-
-    }
-
-    __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:;
-
-    __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:;
-
-    if (unlikely(__pyx_t_6)) {
-
-      __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__14, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 860, __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(4, 860, __pyx_L1_error)
-
-    }
-
-    while (1) {
-      __pyx_t_3 = __Pyx_PyInt_From_int((__pyx_v_offset[0])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 870, __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(4, 870, __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(4, 870, __pyx_L1_error)
-      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-      if (!__pyx_t_6) break;
-
-      (__pyx_v_f[0]) = 0x78;
-
-      __pyx_v_f = (__pyx_v_f + 1);
-
-      __pyx_t_8 = 0;
-      (__pyx_v_offset[__pyx_t_8]) = ((__pyx_v_offset[__pyx_t_8]) + 1);
-    }
-
-    __pyx_t_8 = 0;
-    (__pyx_v_offset[__pyx_t_8]) = ((__pyx_v_offset[__pyx_t_8]) + __pyx_v_child->elsize);
-
-    __pyx_t_6 = ((!(PyDataType_HASFIELDS(__pyx_v_child) != 0)) != 0);
-    if (__pyx_t_6) {
-
-      __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_child->type_num); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 878, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_4);
-      __Pyx_XDECREF_SET(__pyx_v_t, __pyx_t_4);
-      __pyx_t_4 = 0;
-
-      __pyx_t_6 = (((__pyx_v_end - __pyx_v_f) < 5) != 0);
-      if (unlikely(__pyx_t_6)) {
-
-        __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__16, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 880, __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(4, 880, __pyx_L1_error)
-
-      }
-
-      __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_BYTE); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 883, __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(4, 883, __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(4, 883, __pyx_L1_error)
-      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-      if (__pyx_t_6) {
-        (__pyx_v_f[0]) = 98;
-        goto __pyx_L15;
-      }
-
-      __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_UBYTE); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 884, __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(4, 884, __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(4, 884, __pyx_L1_error)
-      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-      if (__pyx_t_6) {
-        (__pyx_v_f[0]) = 66;
-        goto __pyx_L15;
-      }
-
-      __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_SHORT); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 885, __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(4, 885, __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(4, 885, __pyx_L1_error)
-      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-      if (__pyx_t_6) {
-        (__pyx_v_f[0]) = 0x68;
-        goto __pyx_L15;
-      }
-
-      __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_USHORT); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 886, __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(4, 886, __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(4, 886, __pyx_L1_error)
-      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-      if (__pyx_t_6) {
-        (__pyx_v_f[0]) = 72;
-        goto __pyx_L15;
-      }
-
-      __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_INT); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 887, __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(4, 887, __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(4, 887, __pyx_L1_error)
-      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-      if (__pyx_t_6) {
-        (__pyx_v_f[0]) = 0x69;
-        goto __pyx_L15;
-      }
-
-      __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_UINT); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 888, __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(4, 888, __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(4, 888, __pyx_L1_error)
-      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-      if (__pyx_t_6) {
-        (__pyx_v_f[0]) = 73;
-        goto __pyx_L15;
-      }
-
-      __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONG); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 889, __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(4, 889, __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(4, 889, __pyx_L1_error)
-      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-      if (__pyx_t_6) {
-        (__pyx_v_f[0]) = 0x6C;
-        goto __pyx_L15;
-      }
-
-      __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_ULONG); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 890, __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(4, 890, __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(4, 890, __pyx_L1_error)
-      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-      if (__pyx_t_6) {
-        (__pyx_v_f[0]) = 76;
-        goto __pyx_L15;
-      }
-
-      __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONGLONG); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 891, __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(4, 891, __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(4, 891, __pyx_L1_error)
-      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-      if (__pyx_t_6) {
-        (__pyx_v_f[0]) = 0x71;
-        goto __pyx_L15;
-      }
-
-      __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_ULONGLONG); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 892, __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(4, 892, __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(4, 892, __pyx_L1_error)
-      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-      if (__pyx_t_6) {
-        (__pyx_v_f[0]) = 81;
-        goto __pyx_L15;
-      }
-
-      __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_FLOAT); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 893, __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(4, 893, __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(4, 893, __pyx_L1_error)
-      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-      if (__pyx_t_6) {
-        (__pyx_v_f[0]) = 0x66;
-        goto __pyx_L15;
-      }
-
-      __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_DOUBLE); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 894, __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(4, 894, __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(4, 894, __pyx_L1_error)
-      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-      if (__pyx_t_6) {
-        (__pyx_v_f[0]) = 0x64;
-        goto __pyx_L15;
-      }
-
-      __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONGDOUBLE); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 895, __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(4, 895, __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(4, 895, __pyx_L1_error)
-      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-      if (__pyx_t_6) {
-        (__pyx_v_f[0]) = 0x67;
-        goto __pyx_L15;
-      }
-
-      __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CFLOAT); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 896, __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(4, 896, __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(4, 896, __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;
-      }
-
-      __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CDOUBLE); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 897, __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(4, 897, __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(4, 897, __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;
-      }
-
-      __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CLONGDOUBLE); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 898, __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(4, 898, __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(4, 898, __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;
-      }
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_SQRT", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-      __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_OBJECT); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 899, __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(4, 899, __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(4, 899, __pyx_L1_error)
-      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-      if (likely(__pyx_t_6)) {
-        (__pyx_v_f[0]) = 79;
-        goto __pyx_L15;
-      }
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4706, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
 
-      /*else*/ {
-        __pyx_t_3 = __Pyx_PyUnicode_FormatSafe(__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_v_t); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 901, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_3);
-        __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 901, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_4);
-        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-        __Pyx_Raise(__pyx_t_4, 0, 0, 0);
-        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-        __PYX_ERR(4, 901, __pyx_L1_error)
-      }
-      __pyx_L15:;
+  __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real));
 
-      __pyx_v_f = (__pyx_v_f + 1);
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
-      goto __pyx_L13;
-    }
+  __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
 
-    /*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 == ((char *)NULL))) __PYX_ERR(4, 906, __pyx_L1_error)
-      __pyx_v_f = __pyx_t_9;
-    }
-    __pyx_L13:;
+  __pyx_v_retCode = TA_SQRT((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
 
-  }
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_SQRT, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4711, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
-  __pyx_r = __pyx_v_f;
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4712, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
   goto __pyx_L0;
 
 
   /* 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_AddTraceback("talib._ta_lib.stream_SQRT", __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_XDECREF((PyObject *)__pyx_v_real);
+  __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
 
-static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_arr, PyObject *__pyx_v_base) {
+/* Python wrapper */
+static PyObject *__pyx_pw_5talib_7_ta_lib_647stream_STDDEV(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_646stream_STDDEV, "stream_STDDEV(ndarray real, int timeperiod=-0x80000000, double nbdev=-4e37)\n\nSTDDEV(real[, timeperiod=?, nbdev=?])\n\nStandard Deviation (Statistic Functions)\n\nInputs:\n    real: (any ndarray)\nParameters:\n    timeperiod: 5\n    nbdev: 1.0\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_647stream_STDDEV = {"stream_STDDEV", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_647stream_STDDEV, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_646stream_STDDEV};
+static PyObject *__pyx_pw_5talib_7_ta_lib_647stream_STDDEV(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_real = 0;
+  int __pyx_v_timeperiod;
+  double __pyx_v_nbdev;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[3] = {0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("set_array_base", 0);
-
-  Py_INCREF(__pyx_v_base);
-
-  (void)(PyArray_SetBaseObject(__pyx_v_arr, __pyx_v_base));
-
+  __Pyx_RefNannySetupContext("stream_STDDEV (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,&__pyx_mstate_global->__pyx_n_u_nbdev,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 4714, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 4714, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4714, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4714, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_STDDEV", 0) < (0)) __PYX_ERR(5, 4714, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_STDDEV", 0, 1, 3, i); __PYX_ERR(5, 4714, __pyx_L3_error) }
+      }
+    } else {
+      switch (__pyx_nargs) {
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 4714, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4714, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4714, __pyx_L3_error)
+        break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+    }
+    __pyx_v_real = ((PyArrayObject *)values[0]);
+    if (values[1]) {
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 4716, __pyx_L3_error)
+    } else {
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
+    }
+    if (values[2]) {
+      __pyx_v_nbdev = __Pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_nbdev == (double)-1) && PyErr_Occurred())) __PYX_ERR(5, 4716, __pyx_L3_error)
+    } else {
+      __pyx_v_nbdev = ((double)((double)-4e37));
+    }
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("stream_STDDEV", 0, 1, 3, __pyx_nargs); __PYX_ERR(5, 4714, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_STDDEV", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 4716, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_646stream_STDDEV(__pyx_self, __pyx_v_real, __pyx_v_timeperiod, __pyx_v_nbdev);
 
   /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
+  __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
+  return __pyx_r;
 }
 
-
-static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__pyx_v_arr) {
-  PyObject *__pyx_v_base;
+static PyObject *__pyx_pf_5talib_7_ta_lib_646stream_STDDEV(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod, double __pyx_v_nbdev) {
+  npy_intp __pyx_v_length;
+  TA_RetCode __pyx_v_retCode;
+  double *__pyx_v_real_data;
+  int __pyx_v_outbegidx;
+  int __pyx_v_outnbelement;
+  double __pyx_v_outreal;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
-  int __pyx_t_1;
-  __Pyx_RefNannySetupContext("get_array_base", 0);
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_STDDEV", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_v_base = PyArray_BASE(__pyx_v_arr);
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4736, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
 
-  __pyx_t_1 = ((__pyx_v_base == NULL) != 0);
-  if (__pyx_t_1) {
+  __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real));
 
-    __Pyx_XDECREF(__pyx_r);
-    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
-    goto __pyx_L0;
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
-  }
+  __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
+
+  __pyx_v_retCode = TA_STDDEV((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, __pyx_v_nbdev, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
+
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_STDDEV, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4741, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(((PyObject *)__pyx_v_base));
-  __pyx_r = ((PyObject *)__pyx_v_base);
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4742, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
   goto __pyx_L0;
 
 
   /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("talib._ta_lib.stream_STDDEV", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
   __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_real);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
 
-static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) {
-  int __pyx_r;
+/* Python wrapper */
+static PyObject *__pyx_pw_5talib_7_ta_lib_649stream_STOCH(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_648stream_STOCH, "stream_STOCH(ndarray high, ndarray low, ndarray close, int fastk_period=-0x80000000, int slowk_period=-0x80000000, int slowk_matype=0, int slowd_period=-0x80000000, int slowd_matype=0)\n\nSTOCH(high, low, close[, fastk_period=?, slowk_period=?, slowk_matype=?, slowd_period=?, slowd_matype=?])\n\nStochastic (Momentum Indicators)\n\nInputs:\n    prices: ['high', 'low', 'close']\nParameters:\n    fastk_period: 5\n    slowk_period: 3\n    slowk_matype: 0\n    slowd_period: 3\n    slowd_matype: 0\nOutputs:\n    slowk\n    slowd");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_649stream_STOCH = {"stream_STOCH", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_649stream_STOCH, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_648stream_STOCH};
+static PyObject *__pyx_pw_5talib_7_ta_lib_649stream_STOCH(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_high = 0;
+  PyArrayObject *__pyx_v_low = 0;
+  PyArrayObject *__pyx_v_close = 0;
+  int __pyx_v_fastk_period;
+  int __pyx_v_slowk_period;
+  int __pyx_v_slowk_matype;
+  int __pyx_v_slowd_period;
+  int __pyx_v_slowd_matype;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[8] = {0,0,0,0,0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  PyObject *__pyx_r = 0;
   __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);
-
+  __Pyx_RefNannySetupContext("stream_STOCH (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    __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:*/ {
-
-      __pyx_t_4 = _import_array(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(4, 1036, __pyx_L3_error)
-
-    }
-    __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_L8_try_end;
-    __pyx_L3_error:;
-
-    __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(4, 1037, __pyx_L5_except_error)
-      __Pyx_GOTREF(__pyx_t_5);
-      __Pyx_GOTREF(__pyx_t_6);
-      __Pyx_GOTREF(__pyx_t_7);
-
-      __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__17, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(4, 1038, __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(4, 1038, __pyx_L5_except_error)
-    }
-    goto __pyx_L5_except_error;
-    __pyx_L5_except_error:;
-
-    __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_L8_try_end:;
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,&__pyx_mstate_global->__pyx_n_u_fastk_period,&__pyx_mstate_global->__pyx_n_u_slowk_period,&__pyx_mstate_global->__pyx_n_u_slowk_matype,&__pyx_mstate_global->__pyx_n_u_slowd_period,&__pyx_mstate_global->__pyx_n_u_slowd_matype,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 4744, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  8:
+        values[7] = __Pyx_ArgRef_FASTCALL(__pyx_args, 7);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[7])) __PYX_ERR(5, 4744, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  7:
+        values[6] = __Pyx_ArgRef_FASTCALL(__pyx_args, 6);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(5, 4744, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  6:
+        values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(5, 4744, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  5:
+        values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(5, 4744, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 4744, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 4744, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4744, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4744, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_STOCH", 0) < (0)) __PYX_ERR(5, 4744, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 3; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_STOCH", 0, 3, 8, i); __PYX_ERR(5, 4744, __pyx_L3_error) }
+      }
+    } else {
+      switch (__pyx_nargs) {
+        case  8:
+        values[7] = __Pyx_ArgRef_FASTCALL(__pyx_args, 7);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[7])) __PYX_ERR(5, 4744, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  7:
+        values[6] = __Pyx_ArgRef_FASTCALL(__pyx_args, 6);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(5, 4744, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  6:
+        values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(5, 4744, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  5:
+        values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(5, 4744, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 4744, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 4744, __pyx_L3_error)
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4744, __pyx_L3_error)
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4744, __pyx_L3_error)
+        break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+    }
+    __pyx_v_high = ((PyArrayObject *)values[0]);
+    __pyx_v_low = ((PyArrayObject *)values[1]);
+    __pyx_v_close = ((PyArrayObject *)values[2]);
+    if (values[3]) {
+      __pyx_v_fastk_period = __Pyx_PyLong_As_int(values[3]); if (unlikely((__pyx_v_fastk_period == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 4746, __pyx_L3_error)
+    } else {
+      __pyx_v_fastk_period = ((int)((int)-2147483648));
+    }
+    if (values[4]) {
+      __pyx_v_slowk_period = __Pyx_PyLong_As_int(values[4]); if (unlikely((__pyx_v_slowk_period == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 4746, __pyx_L3_error)
+    } else {
+      __pyx_v_slowk_period = ((int)((int)-2147483648));
+    }
+    if (values[5]) {
+      __pyx_v_slowk_matype = __Pyx_PyLong_As_int(values[5]); if (unlikely((__pyx_v_slowk_matype == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 4746, __pyx_L3_error)
+    } else {
+      __pyx_v_slowk_matype = ((int)((int)0));
+    }
+    if (values[6]) {
+      __pyx_v_slowd_period = __Pyx_PyLong_As_int(values[6]); if (unlikely((__pyx_v_slowd_period == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 4746, __pyx_L3_error)
+    } else {
+      __pyx_v_slowd_period = ((int)((int)-2147483648));
+    }
+    if (values[7]) {
+      __pyx_v_slowd_matype = __Pyx_PyLong_As_int(values[7]); if (unlikely((__pyx_v_slowd_matype == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 4746, __pyx_L3_error)
+    } else {
+      __pyx_v_slowd_matype = ((int)((int)0));
+    }
   }
-
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("stream_STOCH", 0, 3, 8, __pyx_nargs); __PYX_ERR(5, 4744, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_STOCH", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 4746, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 4746, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 4746, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_648stream_STOCH(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_fastk_period, __pyx_v_slowk_period, __pyx_v_slowk_matype, __pyx_v_slowd_period, __pyx_v_slowd_matype);
 
   /* 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_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-
-static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) {
-  int __pyx_r;
+static PyObject *__pyx_pf_5talib_7_ta_lib_648stream_STOCH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_fastk_period, int __pyx_v_slowk_period, int __pyx_v_slowk_matype, int __pyx_v_slowd_period, int __pyx_v_slowd_matype) {
+  npy_intp __pyx_v_length;
+  TA_RetCode __pyx_v_retCode;
+  double *__pyx_v_high_data;
+  double *__pyx_v_low_data;
+  double *__pyx_v_close_data;
+  int __pyx_v_outbegidx;
+  int __pyx_v_outnbelement;
+  double __pyx_v_outslowk;
+  double __pyx_v_outslowd;
+  PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  PyObject *__pyx_t_2 = NULL;
+  npy_intp __pyx_t_2;
   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);
+  PyObject *__pyx_t_4 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_STOCH", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_high);
+  __Pyx_INCREF((PyObject *)__pyx_v_low);
+  __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  {
-    __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:*/ {
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4773, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
 
-      __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(4, 1042, __pyx_L3_error)
+  __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high));
 
-    }
-    __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_L8_try_end;
-    __pyx_L3_error:;
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4775, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
 
-    __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(4, 1043, __pyx_L5_except_error)
-      __Pyx_GOTREF(__pyx_t_5);
-      __Pyx_GOTREF(__pyx_t_6);
-      __Pyx_GOTREF(__pyx_t_7);
+  __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low));
 
-      __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__18, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(4, 1044, __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(4, 1044, __pyx_L5_except_error)
-    }
-    goto __pyx_L5_except_error;
-    __pyx_L5_except_error:;
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4777, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
 
-    __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_L8_try_end:;
-  }
+  __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close));
+
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 4779, __pyx_L1_error)
+  __pyx_v_length = __pyx_t_2;
 
+  __pyx_v_outslowk = __pyx_v_5talib_7_ta_lib_NaN;
 
-  /* function exit code */
-  __pyx_r = 0;
+  __pyx_v_outslowd = __pyx_v_5talib_7_ta_lib_NaN;
+
+  __pyx_v_retCode = TA_STOCH((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, __pyx_v_fastk_period, __pyx_v_slowk_period, __pyx_v_slowk_matype, __pyx_v_slowd_period, __pyx_v_slowd_matype, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outslowk), (&__pyx_v_outslowd));
+
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_STOCH, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4783, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outslowk); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4784, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_3 = PyFloat_FromDouble(__pyx_v_outslowd); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 4784, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 4784, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_GIVEREF(__pyx_t_1);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1) != (0)) __PYX_ERR(5, 4784, __pyx_L1_error);
+  __Pyx_GIVEREF(__pyx_t_3);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_3) != (0)) __PYX_ERR(5, 4784, __pyx_L1_error);
+  __pyx_t_1 = 0;
+  __pyx_t_3 = 0;
+  __pyx_r = __pyx_t_4;
+  __pyx_t_4 = 0;
   goto __pyx_L0;
+
+
+  /* function exit code */
   __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_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_AddTraceback("talib._ta_lib.stream_STOCH", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
   __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_high);
+  __Pyx_XDECREF((PyObject *)__pyx_v_low);
+  __Pyx_XDECREF((PyObject *)__pyx_v_close);
+  __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
 
-static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) {
-  int __pyx_r;
+/* Python wrapper */
+static PyObject *__pyx_pw_5talib_7_ta_lib_651stream_STOCHF(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_650stream_STOCHF, "stream_STOCHF(ndarray high, ndarray low, ndarray close, int fastk_period=-0x80000000, int fastd_period=-0x80000000, int fastd_matype=0)\n\nSTOCHF(high, low, close[, fastk_period=?, fastd_period=?, fastd_matype=?])\n\nStochastic Fast (Momentum Indicators)\n\nInputs:\n    prices: ['high', 'low', 'close']\nParameters:\n    fastk_period: 5\n    fastd_period: 3\n    fastd_matype: 0\nOutputs:\n    fastk\n    fastd");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_651stream_STOCHF = {"stream_STOCHF", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_651stream_STOCHF, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_650stream_STOCHF};
+static PyObject *__pyx_pw_5talib_7_ta_lib_651stream_STOCHF(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_high = 0;
+  PyArrayObject *__pyx_v_low = 0;
+  PyArrayObject *__pyx_v_close = 0;
+  int __pyx_v_fastk_period;
+  int __pyx_v_fastd_period;
+  int __pyx_v_fastd_matype;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[6] = {0,0,0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  PyObject *__pyx_r = 0;
   __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);
-
+  __Pyx_RefNannySetupContext("stream_STOCHF (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    __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:*/ {
-
-      __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(4, 1048, __pyx_L3_error)
-
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,&__pyx_mstate_global->__pyx_n_u_fastk_period,&__pyx_mstate_global->__pyx_n_u_fastd_period,&__pyx_mstate_global->__pyx_n_u_fastd_matype,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 4786, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  6:
+        values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(5, 4786, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  5:
+        values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(5, 4786, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 4786, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 4786, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4786, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4786, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_STOCHF", 0) < (0)) __PYX_ERR(5, 4786, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 3; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_STOCHF", 0, 3, 6, i); __PYX_ERR(5, 4786, __pyx_L3_error) }
+      }
+    } else {
+      switch (__pyx_nargs) {
+        case  6:
+        values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(5, 4786, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  5:
+        values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(5, 4786, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 4786, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 4786, __pyx_L3_error)
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4786, __pyx_L3_error)
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4786, __pyx_L3_error)
+        break;
+        default: goto __pyx_L5_argtuple_error;
+      }
     }
-    __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_L8_try_end;
-    __pyx_L3_error:;
-
-    __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(4, 1049, __pyx_L5_except_error)
-      __Pyx_GOTREF(__pyx_t_5);
-      __Pyx_GOTREF(__pyx_t_6);
-      __Pyx_GOTREF(__pyx_t_7);
-
-      __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__18, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(4, 1050, __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(4, 1050, __pyx_L5_except_error)
+    __pyx_v_high = ((PyArrayObject *)values[0]);
+    __pyx_v_low = ((PyArrayObject *)values[1]);
+    __pyx_v_close = ((PyArrayObject *)values[2]);
+    if (values[3]) {
+      __pyx_v_fastk_period = __Pyx_PyLong_As_int(values[3]); if (unlikely((__pyx_v_fastk_period == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 4788, __pyx_L3_error)
+    } else {
+      __pyx_v_fastk_period = ((int)((int)-2147483648));
+    }
+    if (values[4]) {
+      __pyx_v_fastd_period = __Pyx_PyLong_As_int(values[4]); if (unlikely((__pyx_v_fastd_period == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 4788, __pyx_L3_error)
+    } else {
+      __pyx_v_fastd_period = ((int)((int)-2147483648));
+    }
+    if (values[5]) {
+      __pyx_v_fastd_matype = __Pyx_PyLong_As_int(values[5]); if (unlikely((__pyx_v_fastd_matype == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 4788, __pyx_L3_error)
+    } else {
+      __pyx_v_fastd_matype = ((int)((int)0));
     }
-    goto __pyx_L5_except_error;
-    __pyx_L5_except_error:;
-
-    __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_L8_try_end:;
   }
-
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("stream_STOCHF", 0, 3, 6, __pyx_nargs); __PYX_ERR(5, 4786, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_STOCHF", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 4788, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 4788, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 4788, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_650stream_STOCHF(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_fastk_period, __pyx_v_fastd_period, __pyx_v_fastd_matype);
 
   /* 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_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
   __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static PyMethodDef __pyx_methods[] = {
-  {"_ta_check_success", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5talib_7_ta_lib_1_ta_check_success, METH_VARARGS|METH_KEYWORDS, 0},
-  {0, 0, 0, 0}
-};
-
-#if PY_MAJOR_VERSION >= 3
-#if CYTHON_PEP489_MULTI_PHASE_INIT
-static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/
-static int __pyx_pymod_exec__ta_lib(PyObject* module); /*proto*/
-static PyModuleDef_Slot __pyx_moduledef_slots[] = {
-  {Py_mod_create, (void*)__pyx_pymod_create},
-  {Py_mod_exec, (void*)__pyx_pymod_exec__ta_lib},
-  {0, NULL}
-};
-#endif
+static PyObject *__pyx_pf_5talib_7_ta_lib_650stream_STOCHF(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_fastk_period, int __pyx_v_fastd_period, int __pyx_v_fastd_matype) {
+  npy_intp __pyx_v_length;
+  TA_RetCode __pyx_v_retCode;
+  double *__pyx_v_high_data;
+  double *__pyx_v_low_data;
+  double *__pyx_v_close_data;
+  int __pyx_v_outbegidx;
+  int __pyx_v_outnbelement;
+  double __pyx_v_outfastk;
+  double __pyx_v_outfastd;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  npy_intp __pyx_t_2;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_STOCHF", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_high);
+  __Pyx_INCREF((PyObject *)__pyx_v_low);
+  __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-static struct PyModuleDef __pyx_moduledef = {
-    PyModuleDef_HEAD_INIT,
-    "_ta_lib",
-    0, /* m_doc */
-  #if CYTHON_PEP489_MULTI_PHASE_INIT
-    0, /* m_size */
-  #else
-    -1, /* m_size */
-  #endif
-    __pyx_methods /* m_methods */,
-  #if CYTHON_PEP489_MULTI_PHASE_INIT
-    __pyx_moduledef_slots, /* m_slots */
-  #else
-    NULL, /* m_reload */
-  #endif
-    NULL, /* m_traverse */
-    NULL, /* m_clear */
-    NULL /* m_free */
-};
-#endif
-#ifndef CYTHON_SMALL_CODE
-#if defined(__clang__)
-    #define CYTHON_SMALL_CODE
-#elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3))
-    #define CYTHON_SMALL_CODE __attribute__((cold))
-#else
-    #define CYTHON_SMALL_CODE
-#endif
-#endif
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4813, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
 
-static __Pyx_StringTabEntry __pyx_string_tab[] = {
-  {&__pyx_kp_s_3, __pyx_k_3, sizeof(__pyx_k_3), 0, 0, 1, 0},
-  {&__pyx_n_s_ACOS, __pyx_k_ACOS, sizeof(__pyx_k_ACOS), 0, 0, 1, 1},
-  {&__pyx_n_s_AD, __pyx_k_AD, sizeof(__pyx_k_AD), 0, 0, 1, 1},
-  {&__pyx_n_s_ADD, __pyx_k_ADD, sizeof(__pyx_k_ADD), 0, 0, 1, 1},
-  {&__pyx_n_s_ADOSC, __pyx_k_ADOSC, sizeof(__pyx_k_ADOSC), 0, 0, 1, 1},
-  {&__pyx_n_s_ADX, __pyx_k_ADX, sizeof(__pyx_k_ADX), 0, 0, 1, 1},
-  {&__pyx_n_s_ADXR, __pyx_k_ADXR, sizeof(__pyx_k_ADXR), 0, 0, 1, 1},
-  {&__pyx_n_s_ALL, __pyx_k_ALL, sizeof(__pyx_k_ALL), 0, 0, 1, 1},
-  {&__pyx_n_s_APO, __pyx_k_APO, sizeof(__pyx_k_APO), 0, 0, 1, 1},
-  {&__pyx_n_s_AROON, __pyx_k_AROON, sizeof(__pyx_k_AROON), 0, 0, 1, 1},
-  {&__pyx_n_s_AROONOSC, __pyx_k_AROONOSC, sizeof(__pyx_k_AROONOSC), 0, 0, 1, 1},
-  {&__pyx_n_s_ARRAY_TYPES, __pyx_k_ARRAY_TYPES, sizeof(__pyx_k_ARRAY_TYPES), 0, 0, 1, 1},
-  {&__pyx_n_s_ASIN, __pyx_k_ASIN, sizeof(__pyx_k_ASIN), 0, 0, 1, 1},
-  {&__pyx_n_s_ATAN, __pyx_k_ATAN, sizeof(__pyx_k_ATAN), 0, 0, 1, 1},
-  {&__pyx_n_s_ATR, __pyx_k_ATR, sizeof(__pyx_k_ATR), 0, 0, 1, 1},
-  {&__pyx_n_s_AVGPRICE, __pyx_k_AVGPRICE, sizeof(__pyx_k_AVGPRICE), 0, 0, 1, 1},
-  {&__pyx_n_s_AllCandleSettings, __pyx_k_AllCandleSettings, sizeof(__pyx_k_AllCandleSettings), 0, 0, 1, 1},
-  {&__pyx_kp_s_Allocation_Error_TA_ALLOC_ERR, __pyx_k_Allocation_Error_TA_ALLOC_ERR, sizeof(__pyx_k_Allocation_Error_TA_ALLOC_ERR), 0, 0, 1, 0},
-  {&__pyx_n_s_BBANDS, __pyx_k_BBANDS, sizeof(__pyx_k_BBANDS), 0, 0, 1, 1},
-  {&__pyx_n_s_BETA, __pyx_k_BETA, sizeof(__pyx_k_BETA), 0, 0, 1, 1},
-  {&__pyx_n_s_BOP, __pyx_k_BOP, sizeof(__pyx_k_BOP), 0, 0, 1, 1},
-  {&__pyx_kp_s_Bad_Object_TA_BAD_OBJECT, __pyx_k_Bad_Object_TA_BAD_OBJECT, sizeof(__pyx_k_Bad_Object_TA_BAD_OBJECT), 0, 0, 1, 0},
-  {&__pyx_kp_s_Bad_Parameter_TA_BAD_PARAM, __pyx_k_Bad_Parameter_TA_BAD_PARAM, sizeof(__pyx_k_Bad_Parameter_TA_BAD_PARAM), 0, 0, 1, 0},
-  {&__pyx_n_s_BodyDoji, __pyx_k_BodyDoji, sizeof(__pyx_k_BodyDoji), 0, 0, 1, 1},
-  {&__pyx_n_s_BodyLong, __pyx_k_BodyLong, sizeof(__pyx_k_BodyLong), 0, 0, 1, 1},
-  {&__pyx_n_s_BodyShort, __pyx_k_BodyShort, sizeof(__pyx_k_BodyShort), 0, 0, 1, 1},
-  {&__pyx_n_s_BodyVeryLong, __pyx_k_BodyVeryLong, sizeof(__pyx_k_BodyVeryLong), 0, 0, 1, 1},
-  {&__pyx_kp_s_Bull_Bear_Pattern_Bearish_0_Neut, __pyx_k_Bull_Bear_Pattern_Bearish_0_Neut, sizeof(__pyx_k_Bull_Bear_Pattern_Bearish_0_Neut), 0, 0, 1, 0},
-  {&__pyx_n_s_CCI, __pyx_k_CCI, sizeof(__pyx_k_CCI), 0, 0, 1, 1},
-  {&__pyx_n_s_CDL2CROWS, __pyx_k_CDL2CROWS, sizeof(__pyx_k_CDL2CROWS), 0, 0, 1, 1},
-  {&__pyx_n_s_CDL3BLACKCROWS, __pyx_k_CDL3BLACKCROWS, sizeof(__pyx_k_CDL3BLACKCROWS), 0, 0, 1, 1},
-  {&__pyx_n_s_CDL3INSIDE, __pyx_k_CDL3INSIDE, sizeof(__pyx_k_CDL3INSIDE), 0, 0, 1, 1},
-  {&__pyx_n_s_CDL3LINESTRIKE, __pyx_k_CDL3LINESTRIKE, sizeof(__pyx_k_CDL3LINESTRIKE), 0, 0, 1, 1},
-  {&__pyx_n_s_CDL3OUTSIDE, __pyx_k_CDL3OUTSIDE, sizeof(__pyx_k_CDL3OUTSIDE), 0, 0, 1, 1},
-  {&__pyx_n_s_CDL3STARSINSOUTH, __pyx_k_CDL3STARSINSOUTH, sizeof(__pyx_k_CDL3STARSINSOUTH), 0, 0, 1, 1},
-  {&__pyx_n_s_CDL3WHITESOLDIERS, __pyx_k_CDL3WHITESOLDIERS, sizeof(__pyx_k_CDL3WHITESOLDIERS), 0, 0, 1, 1},
-  {&__pyx_n_s_CDLABANDONEDBABY, __pyx_k_CDLABANDONEDBABY, sizeof(__pyx_k_CDLABANDONEDBABY), 0, 0, 1, 1},
-  {&__pyx_n_s_CDLADVANCEBLOCK, __pyx_k_CDLADVANCEBLOCK, sizeof(__pyx_k_CDLADVANCEBLOCK), 0, 0, 1, 1},
-  {&__pyx_n_s_CDLBELTHOLD, __pyx_k_CDLBELTHOLD, sizeof(__pyx_k_CDLBELTHOLD), 0, 0, 1, 1},
-  {&__pyx_n_s_CDLBREAKAWAY, __pyx_k_CDLBREAKAWAY, sizeof(__pyx_k_CDLBREAKAWAY), 0, 0, 1, 1},
-  {&__pyx_n_s_CDLCLOSINGMARUBOZU, __pyx_k_CDLCLOSINGMARUBOZU, sizeof(__pyx_k_CDLCLOSINGMARUBOZU), 0, 0, 1, 1},
-  {&__pyx_n_s_CDLCONCEALBABYSWALL, __pyx_k_CDLCONCEALBABYSWALL, sizeof(__pyx_k_CDLCONCEALBABYSWALL), 0, 0, 1, 1},
-  {&__pyx_n_s_CDLCOUNTERATTACK, __pyx_k_CDLCOUNTERATTACK, sizeof(__pyx_k_CDLCOUNTERATTACK), 0, 0, 1, 1},
-  {&__pyx_n_s_CDLDARKCLOUDCOVER, __pyx_k_CDLDARKCLOUDCOVER, sizeof(__pyx_k_CDLDARKCLOUDCOVER), 0, 0, 1, 1},
-  {&__pyx_n_s_CDLDOJI, __pyx_k_CDLDOJI, sizeof(__pyx_k_CDLDOJI), 0, 0, 1, 1},
-  {&__pyx_n_s_CDLDOJISTAR, __pyx_k_CDLDOJISTAR, sizeof(__pyx_k_CDLDOJISTAR), 0, 0, 1, 1},
-  {&__pyx_n_s_CDLDRAGONFLYDOJI, __pyx_k_CDLDRAGONFLYDOJI, sizeof(__pyx_k_CDLDRAGONFLYDOJI), 0, 0, 1, 1},
-  {&__pyx_n_s_CDLENGULFING, __pyx_k_CDLENGULFING, sizeof(__pyx_k_CDLENGULFING), 0, 0, 1, 1},
-  {&__pyx_n_s_CDLEVENINGDOJISTAR, __pyx_k_CDLEVENINGDOJISTAR, sizeof(__pyx_k_CDLEVENINGDOJISTAR), 0, 0, 1, 1},
-  {&__pyx_n_s_CDLEVENINGSTAR, __pyx_k_CDLEVENINGSTAR, sizeof(__pyx_k_CDLEVENINGSTAR), 0, 0, 1, 1},
-  {&__pyx_n_s_CDLGAPSIDESIDEWHITE, __pyx_k_CDLGAPSIDESIDEWHITE, sizeof(__pyx_k_CDLGAPSIDESIDEWHITE), 0, 0, 1, 1},
-  {&__pyx_n_s_CDLGRAVESTONEDOJI, __pyx_k_CDLGRAVESTONEDOJI, sizeof(__pyx_k_CDLGRAVESTONEDOJI), 0, 0, 1, 1},
-  {&__pyx_n_s_CDLHAMMER, __pyx_k_CDLHAMMER, sizeof(__pyx_k_CDLHAMMER), 0, 0, 1, 1},
-  {&__pyx_n_s_CDLHANGINGMAN, __pyx_k_CDLHANGINGMAN, sizeof(__pyx_k_CDLHANGINGMAN), 0, 0, 1, 1},
-  {&__pyx_n_s_CDLHARAMI, __pyx_k_CDLHARAMI, sizeof(__pyx_k_CDLHARAMI), 0, 0, 1, 1},
-  {&__pyx_n_s_CDLHARAMICROSS, __pyx_k_CDLHARAMICROSS, sizeof(__pyx_k_CDLHARAMICROSS), 0, 0, 1, 1},
-  {&__pyx_n_s_CDLHIGHWAVE, __pyx_k_CDLHIGHWAVE, sizeof(__pyx_k_CDLHIGHWAVE), 0, 0, 1, 1},
-  {&__pyx_n_s_CDLHIKKAKE, __pyx_k_CDLHIKKAKE, sizeof(__pyx_k_CDLHIKKAKE), 0, 0, 1, 1},
-  {&__pyx_n_s_CDLHIKKAKEMOD, __pyx_k_CDLHIKKAKEMOD, sizeof(__pyx_k_CDLHIKKAKEMOD), 0, 0, 1, 1},
-  {&__pyx_n_s_CDLHOMINGPIGEON, __pyx_k_CDLHOMINGPIGEON, sizeof(__pyx_k_CDLHOMINGPIGEON), 0, 0, 1, 1},
-  {&__pyx_n_s_CDLIDENTICAL3CROWS, __pyx_k_CDLIDENTICAL3CROWS, sizeof(__pyx_k_CDLIDENTICAL3CROWS), 0, 0, 1, 1},
-  {&__pyx_n_s_CDLINNECK, __pyx_k_CDLINNECK, sizeof(__pyx_k_CDLINNECK), 0, 0, 1, 1},
-  {&__pyx_n_s_CDLINVERTEDHAMMER, __pyx_k_CDLINVERTEDHAMMER, sizeof(__pyx_k_CDLINVERTEDHAMMER), 0, 0, 1, 1},
-  {&__pyx_n_s_CDLKICKING, __pyx_k_CDLKICKING, sizeof(__pyx_k_CDLKICKING), 0, 0, 1, 1},
-  {&__pyx_n_s_CDLKICKINGBYLENGTH, __pyx_k_CDLKICKINGBYLENGTH, sizeof(__pyx_k_CDLKICKINGBYLENGTH), 0, 0, 1, 1},
-  {&__pyx_n_s_CDLLADDERBOTTOM, __pyx_k_CDLLADDERBOTTOM, sizeof(__pyx_k_CDLLADDERBOTTOM), 0, 0, 1, 1},
-  {&__pyx_n_s_CDLLONGLEGGEDDOJI, __pyx_k_CDLLONGLEGGEDDOJI, sizeof(__pyx_k_CDLLONGLEGGEDDOJI), 0, 0, 1, 1},
-  {&__pyx_n_s_CDLLONGLINE, __pyx_k_CDLLONGLINE, sizeof(__pyx_k_CDLLONGLINE), 0, 0, 1, 1},
-  {&__pyx_n_s_CDLMARUBOZU, __pyx_k_CDLMARUBOZU, sizeof(__pyx_k_CDLMARUBOZU), 0, 0, 1, 1},
-  {&__pyx_n_s_CDLMATCHINGLOW, __pyx_k_CDLMATCHINGLOW, sizeof(__pyx_k_CDLMATCHINGLOW), 0, 0, 1, 1},
-  {&__pyx_n_s_CDLMATHOLD, __pyx_k_CDLMATHOLD, sizeof(__pyx_k_CDLMATHOLD), 0, 0, 1, 1},
-  {&__pyx_n_s_CDLMORNINGDOJISTAR, __pyx_k_CDLMORNINGDOJISTAR, sizeof(__pyx_k_CDLMORNINGDOJISTAR), 0, 0, 1, 1},
-  {&__pyx_n_s_CDLMORNINGSTAR, __pyx_k_CDLMORNINGSTAR, sizeof(__pyx_k_CDLMORNINGSTAR), 0, 0, 1, 1},
-  {&__pyx_n_s_CDLONNECK, __pyx_k_CDLONNECK, sizeof(__pyx_k_CDLONNECK), 0, 0, 1, 1},
-  {&__pyx_n_s_CDLPIERCING, __pyx_k_CDLPIERCING, sizeof(__pyx_k_CDLPIERCING), 0, 0, 1, 1},
-  {&__pyx_n_s_CDLRICKSHAWMAN, __pyx_k_CDLRICKSHAWMAN, sizeof(__pyx_k_CDLRICKSHAWMAN), 0, 0, 1, 1},
-  {&__pyx_n_s_CDLRISEFALL3METHODS, __pyx_k_CDLRISEFALL3METHODS, sizeof(__pyx_k_CDLRISEFALL3METHODS), 0, 0, 1, 1},
-  {&__pyx_n_s_CDLSEPARATINGLINES, __pyx_k_CDLSEPARATINGLINES, sizeof(__pyx_k_CDLSEPARATINGLINES), 0, 0, 1, 1},
-  {&__pyx_n_s_CDLSHOOTINGSTAR, __pyx_k_CDLSHOOTINGSTAR, sizeof(__pyx_k_CDLSHOOTINGSTAR), 0, 0, 1, 1},
-  {&__pyx_n_s_CDLSHORTLINE, __pyx_k_CDLSHORTLINE, sizeof(__pyx_k_CDLSHORTLINE), 0, 0, 1, 1},
-  {&__pyx_n_s_CDLSPINNINGTOP, __pyx_k_CDLSPINNINGTOP, sizeof(__pyx_k_CDLSPINNINGTOP), 0, 0, 1, 1},
-  {&__pyx_n_s_CDLSTALLEDPATTERN, __pyx_k_CDLSTALLEDPATTERN, sizeof(__pyx_k_CDLSTALLEDPATTERN), 0, 0, 1, 1},
-  {&__pyx_n_s_CDLSTICKSANDWICH, __pyx_k_CDLSTICKSANDWICH, sizeof(__pyx_k_CDLSTICKSANDWICH), 0, 0, 1, 1},
-  {&__pyx_n_s_CDLTAKURI, __pyx_k_CDLTAKURI, sizeof(__pyx_k_CDLTAKURI), 0, 0, 1, 1},
-  {&__pyx_n_s_CDLTASUKIGAP, __pyx_k_CDLTASUKIGAP, sizeof(__pyx_k_CDLTASUKIGAP), 0, 0, 1, 1},
-  {&__pyx_n_s_CDLTHRUSTING, __pyx_k_CDLTHRUSTING, sizeof(__pyx_k_CDLTHRUSTING), 0, 0, 1, 1},
-  {&__pyx_n_s_CDLTRISTAR, __pyx_k_CDLTRISTAR, sizeof(__pyx_k_CDLTRISTAR), 0, 0, 1, 1},
-  {&__pyx_n_s_CDLUNIQUE3RIVER, __pyx_k_CDLUNIQUE3RIVER, sizeof(__pyx_k_CDLUNIQUE3RIVER), 0, 0, 1, 1},
-  {&__pyx_n_s_CDLUPSIDEGAP2CROWS, __pyx_k_CDLUPSIDEGAP2CROWS, sizeof(__pyx_k_CDLUPSIDEGAP2CROWS), 0, 0, 1, 1},
-  {&__pyx_n_s_CDLXSIDEGAP3METHODS, __pyx_k_CDLXSIDEGAP3METHODS, sizeof(__pyx_k_CDLXSIDEGAP3METHODS), 0, 0, 1, 1},
-  {&__pyx_n_s_CEIL, __pyx_k_CEIL, sizeof(__pyx_k_CEIL), 0, 0, 1, 1},
-  {&__pyx_n_s_CMO, __pyx_k_CMO, sizeof(__pyx_k_CMO), 0, 0, 1, 1},
-  {&__pyx_n_s_CORREL, __pyx_k_CORREL, sizeof(__pyx_k_CORREL), 0, 0, 1, 1},
-  {&__pyx_n_s_COS, __pyx_k_COS, sizeof(__pyx_k_COS), 0, 0, 1, 1},
-  {&__pyx_n_s_COSH, __pyx_k_COSH, sizeof(__pyx_k_COSH), 0, 0, 1, 1},
-  {&__pyx_n_s_CandleSettingType, __pyx_k_CandleSettingType, sizeof(__pyx_k_CandleSettingType), 0, 0, 1, 1},
-  {&__pyx_n_s_DEMA, __pyx_k_DEMA, sizeof(__pyx_k_DEMA), 0, 0, 1, 1},
-  {&__pyx_n_s_DIV, __pyx_k_DIV, sizeof(__pyx_k_DIV), 0, 0, 1, 1},
-  {&__pyx_n_s_DX, __pyx_k_DX, sizeof(__pyx_k_DX), 0, 0, 1, 1},
-  {&__pyx_kp_s_Dashed_Line, __pyx_k_Dashed_Line, sizeof(__pyx_k_Dashed_Line), 0, 0, 1, 0},
-  {&__pyx_n_s_DataFrame, __pyx_k_DataFrame, sizeof(__pyx_k_DataFrame), 0, 0, 1, 1},
-  {&__pyx_n_s_Dot, __pyx_k_Dot, sizeof(__pyx_k_Dot), 0, 0, 1, 1},
-  {&__pyx_kp_s_Dotted_Line, __pyx_k_Dotted_Line, sizeof(__pyx_k_Dotted_Line), 0, 0, 1, 0},
-  {&__pyx_kp_s_Double_Exponential_Moving_Averag, __pyx_k_Double_Exponential_Moving_Averag, sizeof(__pyx_k_Double_Exponential_Moving_Averag), 0, 0, 1, 0},
-  {&__pyx_n_s_EMA, __pyx_k_EMA, sizeof(__pyx_k_EMA), 0, 0, 1, 1},
-  {&__pyx_n_s_EXP, __pyx_k_EXP, sizeof(__pyx_k_EXP), 0, 0, 1, 1},
-  {&__pyx_n_s_Equal, __pyx_k_Equal, sizeof(__pyx_k_Equal), 0, 0, 1, 1},
-  {&__pyx_kp_s_Exponential_Moving_Average, __pyx_k_Exponential_Moving_Average, sizeof(__pyx_k_Exponential_Moving_Average), 0, 0, 1, 0},
-  {&__pyx_n_s_FLOOR, __pyx_k_FLOOR, sizeof(__pyx_k_FLOOR), 0, 0, 1, 1},
-  {&__pyx_n_s_Far, __pyx_k_Far, sizeof(__pyx_k_Far), 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_Function, __pyx_k_Function, sizeof(__pyx_k_Function), 0, 0, 1, 1},
-  {&__pyx_kp_s_Function_Not_Found_TA_FUNC_NOT_F, __pyx_k_Function_Not_Found_TA_FUNC_NOT_F, sizeof(__pyx_k_Function_Not_Found_TA_FUNC_NOT_F), 0, 0, 1, 0},
-  {&__pyx_n_s_Function___call, __pyx_k_Function___call, sizeof(__pyx_k_Function___call), 0, 0, 1, 1},
-  {&__pyx_n_s_Function___call_function, __pyx_k_Function___call_function, sizeof(__pyx_k_Function___call_function), 0, 0, 1, 1},
-  {&__pyx_n_s_Function___check_opt_input_value, __pyx_k_Function___check_opt_input_value, sizeof(__pyx_k_Function___check_opt_input_value), 0, 0, 1, 1},
-  {&__pyx_n_s_Function___get_opt_input_value, __pyx_k_Function___get_opt_input_value, sizeof(__pyx_k_Function___get_opt_input_value), 0, 0, 1, 1},
-  {&__pyx_n_s_Function___init, __pyx_k_Function___init, sizeof(__pyx_k_Function___init), 0, 0, 1, 1},
-  {&__pyx_n_s_Function___initialize_function_i, __pyx_k_Function___initialize_function_i, sizeof(__pyx_k_Function___initialize_function_i), 0, 0, 1, 1},
-  {&__pyx_n_s_Function___input_price_series_na, __pyx_k_Function___input_price_series_na, sizeof(__pyx_k_Function___input_price_series_na), 0, 0, 1, 1},
-  {&__pyx_n_s_Function___repr, __pyx_k_Function___repr, sizeof(__pyx_k_Function___repr), 0, 0, 1, 1},
-  {&__pyx_n_s_Function___str, __pyx_k_Function___str, sizeof(__pyx_k_Function___str), 0, 0, 1, 1},
-  {&__pyx_n_s_Function___unicode, __pyx_k_Function___unicode, sizeof(__pyx_k_Function___unicode), 0, 0, 1, 1},
-  {&__pyx_n_s_Function__call_function, __pyx_k_Function__call_function, sizeof(__pyx_k_Function__call_function), 0, 0, 1, 1},
-  {&__pyx_n_s_Function__check_opt_input_value, __pyx_k_Function__check_opt_input_value, sizeof(__pyx_k_Function__check_opt_input_value), 0, 0, 1, 1},
-  {&__pyx_n_s_Function__get_opt_input_value, __pyx_k_Function__get_opt_input_value, sizeof(__pyx_k_Function__get_opt_input_value), 0, 0, 1, 1},
-  {&__pyx_n_s_Function__info, __pyx_k_Function__info, sizeof(__pyx_k_Function__info), 0, 0, 1, 1},
-  {&__pyx_n_s_Function__initialize_function_i, __pyx_k_Function__initialize_function_i, sizeof(__pyx_k_Function__initialize_function_i), 0, 0, 1, 1},
-  {&__pyx_n_s_Function__input_arrays, __pyx_k_Function__input_arrays, sizeof(__pyx_k_Function__input_arrays), 0, 0, 1, 1},
-  {&__pyx_n_s_Function__input_names, __pyx_k_Function__input_names, sizeof(__pyx_k_Function__input_names), 0, 0, 1, 1},
-  {&__pyx_n_s_Function__input_price_series_na, __pyx_k_Function__input_price_series_na, sizeof(__pyx_k_Function__input_price_series_na), 0, 0, 1, 1},
-  {&__pyx_n_s_Function__name, __pyx_k_Function__name, sizeof(__pyx_k_Function__name), 0, 0, 1, 1},
-  {&__pyx_n_s_Function__namestr, __pyx_k_Function__namestr, sizeof(__pyx_k_Function__namestr), 0, 0, 1, 1},
-  {&__pyx_n_s_Function__opt_inputs, __pyx_k_Function__opt_inputs, sizeof(__pyx_k_Function__opt_inputs), 0, 0, 1, 1},
-  {&__pyx_n_s_Function__outputs, __pyx_k_Function__outputs, sizeof(__pyx_k_Function__outputs), 0, 0, 1, 1},
-  {&__pyx_n_s_Function__outputs_valid, __pyx_k_Function__outputs_valid, sizeof(__pyx_k_Function__outputs_valid), 0, 0, 1, 1},
-  {&__pyx_n_s_Function_function_flags, __pyx_k_Function_function_flags, sizeof(__pyx_k_Function_function_flags), 0, 0, 1, 1},
-  {&__pyx_n_s_Function_get_input_arrays, __pyx_k_Function_get_input_arrays, sizeof(__pyx_k_Function_get_input_arrays), 0, 0, 1, 1},
-  {&__pyx_n_s_Function_get_input_names, __pyx_k_Function_get_input_names, sizeof(__pyx_k_Function_get_input_names), 0, 0, 1, 1},
-  {&__pyx_n_s_Function_get_parameters, __pyx_k_Function_get_parameters, sizeof(__pyx_k_Function_get_parameters), 0, 0, 1, 1},
-  {&__pyx_kp_s_Function_has_an_unstable_period, __pyx_k_Function_has_an_unstable_period, sizeof(__pyx_k_Function_has_an_unstable_period), 0, 0, 1, 0},
-  {&__pyx_n_s_Function_info, __pyx_k_Function_info, sizeof(__pyx_k_Function_info), 0, 0, 1, 1},
-  {&__pyx_n_s_Function_lookback, __pyx_k_Function_lookback, sizeof(__pyx_k_Function_lookback), 0, 0, 1, 1},
-  {&__pyx_n_s_Function_output_flags, __pyx_k_Function_output_flags, sizeof(__pyx_k_Function_output_flags), 0, 0, 1, 1},
-  {&__pyx_n_s_Function_output_names, __pyx_k_Function_output_names, sizeof(__pyx_k_Function_output_names), 0, 0, 1, 1},
-  {&__pyx_n_s_Function_outputs, __pyx_k_Function_outputs, sizeof(__pyx_k_Function_outputs), 0, 0, 1, 1},
-  {&__pyx_n_s_Function_run, __pyx_k_Function_run, sizeof(__pyx_k_Function_run), 0, 0, 1, 1},
-  {&__pyx_n_s_Function_set_function_args, __pyx_k_Function_set_function_args, sizeof(__pyx_k_Function_set_function_args), 0, 0, 1, 1},
-  {&__pyx_n_s_Function_set_input_arrays, __pyx_k_Function_set_input_arrays, sizeof(__pyx_k_Function_set_input_arrays), 0, 0, 1, 1},
-  {&__pyx_n_s_Function_set_input_names, __pyx_k_Function_set_input_names, sizeof(__pyx_k_Function_set_input_names), 0, 0, 1, 1},
-  {&__pyx_n_s_Function_set_parameters, __pyx_k_Function_set_parameters, sizeof(__pyx_k_Function_set_parameters), 0, 0, 1, 1},
-  {&__pyx_kp_s_Group_Not_Found_TA_GROUP_NOT_FOU, __pyx_k_Group_Not_Found_TA_GROUP_NOT_FOU, sizeof(__pyx_k_Group_Not_Found_TA_GROUP_NOT_FOU), 0, 0, 1, 0},
-  {&__pyx_n_s_HT_DCPERIOD, __pyx_k_HT_DCPERIOD, sizeof(__pyx_k_HT_DCPERIOD), 0, 0, 1, 1},
-  {&__pyx_n_s_HT_DCPHASE, __pyx_k_HT_DCPHASE, sizeof(__pyx_k_HT_DCPHASE), 0, 0, 1, 1},
-  {&__pyx_n_s_HT_PHASOR, __pyx_k_HT_PHASOR, sizeof(__pyx_k_HT_PHASOR), 0, 0, 1, 1},
-  {&__pyx_n_s_HT_SINE, __pyx_k_HT_SINE, sizeof(__pyx_k_HT_SINE), 0, 0, 1, 1},
-  {&__pyx_n_s_HT_TRENDLINE, __pyx_k_HT_TRENDLINE, sizeof(__pyx_k_HT_TRENDLINE), 0, 0, 1, 1},
-  {&__pyx_n_s_HT_TRENDMODE, __pyx_k_HT_TRENDMODE, sizeof(__pyx_k_HT_TRENDMODE), 0, 0, 1, 1},
-  {&__pyx_n_s_HighLow, __pyx_k_HighLow, sizeof(__pyx_k_HighLow), 0, 0, 1, 1},
-  {&__pyx_n_s_Histogram, __pyx_k_Histogram, sizeof(__pyx_k_Histogram), 0, 0, 1, 1},
-  {&__pyx_n_s_INPUT_ARRAYS_DEFAULTS, __pyx_k_INPUT_ARRAYS_DEFAULTS, sizeof(__pyx_k_INPUT_ARRAYS_DEFAULTS), 0, 0, 1, 1},
-  {&__pyx_n_s_INPUT_ARRAYS_TYPES, __pyx_k_INPUT_ARRAYS_TYPES, sizeof(__pyx_k_INPUT_ARRAYS_TYPES), 0, 0, 1, 1},
-  {&__pyx_n_s_INPUT_PRICE_SERIES_DEFAULTS, __pyx_k_INPUT_PRICE_SERIES_DEFAULTS, sizeof(__pyx_k_INPUT_PRICE_SERIES_DEFAULTS), 0, 0, 1, 1},
-  {&__pyx_n_s_ImportError, __pyx_k_ImportError, sizeof(__pyx_k_ImportError), 0, 0, 1, 1},
-  {&__pyx_n_s_IndexError, __pyx_k_IndexError, sizeof(__pyx_k_IndexError), 0, 0, 1, 1},
-  {&__pyx_kp_s_Input_Not_All_Initialized_TA_INP, __pyx_k_Input_Not_All_Initialized_TA_INP, sizeof(__pyx_k_Input_Not_All_Initialized_TA_INP), 0, 0, 1, 0},
-  {&__pyx_kp_s_Inputs, __pyx_k_Inputs, sizeof(__pyx_k_Inputs), 0, 0, 1, 0},
-  {&__pyx_kp_s_Internal_Error_TA_INTERNAL_ERROR, __pyx_k_Internal_Error_TA_INTERNAL_ERROR, sizeof(__pyx_k_Internal_Error_TA_INTERNAL_ERROR), 0, 0, 1, 0},
-  {&__pyx_kp_s_Invalid_Handle_TA_INVALID_HANDLE, __pyx_k_Invalid_Handle_TA_INVALID_HANDLE, sizeof(__pyx_k_Invalid_Handle_TA_INVALID_HANDLE), 0, 0, 1, 0},
-  {&__pyx_kp_s_Invalid_List_Type_TA_INVALID_LIS, __pyx_k_Invalid_List_Type_TA_INVALID_LIS, sizeof(__pyx_k_Invalid_List_Type_TA_INVALID_LIS), 0, 0, 1, 0},
-  {&__pyx_kp_s_Invalid_Parameter_Function_TA_IN, __pyx_k_Invalid_Parameter_Function_TA_IN, sizeof(__pyx_k_Invalid_Parameter_Function_TA_IN), 0, 0, 1, 0},
-  {&__pyx_kp_s_Invalid_Parameter_Holder_TA_INVA, __pyx_k_Invalid_Parameter_Holder_TA_INVA, sizeof(__pyx_k_Invalid_Parameter_Holder_TA_INVA), 0, 0, 1, 0},
-  {&__pyx_kp_s_Invalid_Parameter_Holder_Type_TA, __pyx_k_Invalid_Parameter_Holder_Type_TA, sizeof(__pyx_k_Invalid_Parameter_Holder_Type_TA), 0, 0, 1, 0},
-  {&__pyx_kp_s_Invalid_parameter_value_for_s_ex, __pyx_k_Invalid_parameter_value_for_s_ex, sizeof(__pyx_k_Invalid_parameter_value_for_s_ex), 0, 0, 1, 0},
-  {&__pyx_n_s_KAMA, __pyx_k_KAMA, sizeof(__pyx_k_KAMA), 0, 0, 1, 1},
-  {&__pyx_kp_s_Kaufman_Adaptive_Moving_Average, __pyx_k_Kaufman_Adaptive_Moving_Average, sizeof(__pyx_k_Kaufman_Adaptive_Moving_Average), 0, 0, 1, 0},
-  {&__pyx_n_s_LINEARREG, __pyx_k_LINEARREG, sizeof(__pyx_k_LINEARREG), 0, 0, 1, 1},
-  {&__pyx_n_s_LINEARREG_ANGLE, __pyx_k_LINEARREG_ANGLE, sizeof(__pyx_k_LINEARREG_ANGLE), 0, 0, 1, 1},
-  {&__pyx_n_s_LINEARREG_INTERCEPT, __pyx_k_LINEARREG_INTERCEPT, sizeof(__pyx_k_LINEARREG_INTERCEPT), 0, 0, 1, 1},
-  {&__pyx_n_s_LINEARREG_SLOPE, __pyx_k_LINEARREG_SLOPE, sizeof(__pyx_k_LINEARREG_SLOPE), 0, 0, 1, 1},
-  {&__pyx_n_s_LN, __pyx_k_LN, sizeof(__pyx_k_LN), 0, 0, 1, 1},
-  {&__pyx_n_s_LOG10, __pyx_k_LOG10, sizeof(__pyx_k_LOG10), 0, 0, 1, 1},
-  {&__pyx_kp_s_Library_Not_Initialized_TA_LIB_N, __pyx_k_Library_Not_Initialized_TA_LIB_N, sizeof(__pyx_k_Library_Not_Initialized_TA_LIB_N), 0, 0, 1, 0},
-  {&__pyx_n_s_Line, __pyx_k_Line, sizeof(__pyx_k_Line), 0, 0, 1, 1},
-  {&__pyx_n_s_MA, __pyx_k_MA, sizeof(__pyx_k_MA), 0, 0, 1, 1},
-  {&__pyx_n_s_MACD, __pyx_k_MACD, sizeof(__pyx_k_MACD), 0, 0, 1, 1},
-  {&__pyx_n_s_MACDEXT, __pyx_k_MACDEXT, sizeof(__pyx_k_MACDEXT), 0, 0, 1, 1},
-  {&__pyx_n_s_MACDFIX, __pyx_k_MACDFIX, sizeof(__pyx_k_MACDFIX), 0, 0, 1, 1},
-  {&__pyx_n_s_MAMA, __pyx_k_MAMA, sizeof(__pyx_k_MAMA), 0, 0, 1, 1},
-  {&__pyx_n_s_MAVP, __pyx_k_MAVP, sizeof(__pyx_k_MAVP), 0, 0, 1, 1},
-  {&__pyx_n_s_MAX, __pyx_k_MAX, sizeof(__pyx_k_MAX), 0, 0, 1, 1},
-  {&__pyx_n_s_MAXINDEX, __pyx_k_MAXINDEX, sizeof(__pyx_k_MAXINDEX), 0, 0, 1, 1},
-  {&__pyx_n_s_MA_Type, __pyx_k_MA_Type, sizeof(__pyx_k_MA_Type), 0, 0, 1, 1},
-  {&__pyx_n_s_MA_Type___getitem, __pyx_k_MA_Type___getitem, sizeof(__pyx_k_MA_Type___getitem), 0, 0, 1, 1},
-  {&__pyx_n_s_MA_Type___init, __pyx_k_MA_Type___init, sizeof(__pyx_k_MA_Type___init), 0, 0, 1, 1},
-  {&__pyx_n_s_MEDPRICE, __pyx_k_MEDPRICE, sizeof(__pyx_k_MEDPRICE), 0, 0, 1, 1},
-  {&__pyx_kp_s_MESA_Adaptive_Moving_Average, __pyx_k_MESA_Adaptive_Moving_Average, sizeof(__pyx_k_MESA_Adaptive_Moving_Average), 0, 0, 1, 0},
-  {&__pyx_n_s_MFI, __pyx_k_MFI, sizeof(__pyx_k_MFI), 0, 0, 1, 1},
-  {&__pyx_n_s_MIDPOINT, __pyx_k_MIDPOINT, sizeof(__pyx_k_MIDPOINT), 0, 0, 1, 1},
-  {&__pyx_n_s_MIDPRICE, __pyx_k_MIDPRICE, sizeof(__pyx_k_MIDPRICE), 0, 0, 1, 1},
-  {&__pyx_n_s_MIN, __pyx_k_MIN, sizeof(__pyx_k_MIN), 0, 0, 1, 1},
-  {&__pyx_n_s_MININDEX, __pyx_k_MININDEX, sizeof(__pyx_k_MININDEX), 0, 0, 1, 1},
-  {&__pyx_n_s_MINMAX, __pyx_k_MINMAX, sizeof(__pyx_k_MINMAX), 0, 0, 1, 1},
-  {&__pyx_n_s_MINMAXINDEX, __pyx_k_MINMAXINDEX, sizeof(__pyx_k_MINMAXINDEX), 0, 0, 1, 1},
-  {&__pyx_n_s_MINUS_DI, __pyx_k_MINUS_DI, sizeof(__pyx_k_MINUS_DI), 0, 0, 1, 1},
-  {&__pyx_n_s_MINUS_DM, __pyx_k_MINUS_DM, sizeof(__pyx_k_MINUS_DM), 0, 0, 1, 1},
-  {&__pyx_n_s_MOM, __pyx_k_MOM, sizeof(__pyx_k_MOM), 0, 0, 1, 1},
-  {&__pyx_n_s_MULT, __pyx_k_MULT, sizeof(__pyx_k_MULT), 0, 0, 1, 1},
-  {&__pyx_n_s_NATR, __pyx_k_NATR, sizeof(__pyx_k_NATR), 0, 0, 1, 1},
-  {&__pyx_n_s_NONE, __pyx_k_NONE, sizeof(__pyx_k_NONE), 0, 0, 1, 1},
-  {&__pyx_n_s_Near, __pyx_k_Near, sizeof(__pyx_k_Near), 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_kp_s_Not_Supported_TA_NOT_SUPPORTED, __pyx_k_Not_Supported_TA_NOT_SUPPORTED, sizeof(__pyx_k_Not_Supported_TA_NOT_SUPPORTED), 0, 0, 1, 0},
-  {&__pyx_kp_s_Not_enough_price_arguments_expec, __pyx_k_Not_enough_price_arguments_expec, sizeof(__pyx_k_Not_enough_price_arguments_expec), 0, 0, 1, 0},
-  {&__pyx_n_s_OBV, __pyx_k_OBV, sizeof(__pyx_k_OBV), 0, 0, 1, 1},
-  {&__pyx_n_s_OrderedDict, __pyx_k_OrderedDict, sizeof(__pyx_k_OrderedDict), 0, 0, 1, 1},
-  {&__pyx_kp_s_Out_of_Range_End_Index_TA_OUT_OF, __pyx_k_Out_of_Range_End_Index_TA_OUT_OF, sizeof(__pyx_k_Out_of_Range_End_Index_TA_OUT_OF), 0, 0, 1, 0},
-  {&__pyx_kp_s_Out_of_Range_Start_Index_TA_OUT, __pyx_k_Out_of_Range_Start_Index_TA_OUT, sizeof(__pyx_k_Out_of_Range_Start_Index_TA_OUT), 0, 0, 1, 0},
-  {&__pyx_kp_s_Output_Not_All_Initialized_TA_OU, __pyx_k_Output_Not_All_Initialized_TA_OU, sizeof(__pyx_k_Output_Not_All_Initialized_TA_OU), 0, 0, 1, 0},
-  {&__pyx_kp_s_Output_can_be_negative, __pyx_k_Output_can_be_negative, sizeof(__pyx_k_Output_can_be_negative), 0, 0, 1, 0},
-  {&__pyx_kp_s_Output_can_be_positive, __pyx_k_Output_can_be_positive, sizeof(__pyx_k_Output_can_be_positive), 0, 0, 1, 0},
-  {&__pyx_kp_s_Output_can_be_zero, __pyx_k_Output_can_be_zero, sizeof(__pyx_k_Output_can_be_zero), 0, 0, 1, 0},
-  {&__pyx_kp_s_Output_is_a_candlestick, __pyx_k_Output_is_a_candlestick, sizeof(__pyx_k_Output_is_a_candlestick), 0, 0, 1, 0},
-  {&__pyx_kp_s_Output_is_over_volume, __pyx_k_Output_is_over_volume, sizeof(__pyx_k_Output_is_over_volume), 0, 0, 1, 0},
-  {&__pyx_kp_s_Output_scale_same_as_input, __pyx_k_Output_scale_same_as_input, sizeof(__pyx_k_Output_scale_same_as_input), 0, 0, 1, 0},
-  {&__pyx_kp_s_Outputs, __pyx_k_Outputs, sizeof(__pyx_k_Outputs), 0, 0, 1, 0},
-  {&__pyx_n_s_PANDAS_DATAFRAME, __pyx_k_PANDAS_DATAFRAME, sizeof(__pyx_k_PANDAS_DATAFRAME), 0, 0, 1, 1},
-  {&__pyx_n_s_PANDAS_SERIES, __pyx_k_PANDAS_SERIES, sizeof(__pyx_k_PANDAS_SERIES), 0, 0, 1, 1},
-  {&__pyx_n_s_PLUS_DI, __pyx_k_PLUS_DI, sizeof(__pyx_k_PLUS_DI), 0, 0, 1, 1},
-  {&__pyx_n_s_PLUS_DM, __pyx_k_PLUS_DM, sizeof(__pyx_k_PLUS_DM), 0, 0, 1, 1},
-  {&__pyx_n_s_PPO, __pyx_k_PPO, sizeof(__pyx_k_PPO), 0, 0, 1, 1},
-  {&__pyx_kp_s_Parameters, __pyx_k_Parameters, sizeof(__pyx_k_Parameters), 0, 0, 1, 0},
-  {&__pyx_kp_s_Pattern_Bool, __pyx_k_Pattern_Bool, sizeof(__pyx_k_Pattern_Bool), 0, 0, 1, 0},
-  {&__pyx_n_s_ROC, __pyx_k_ROC, sizeof(__pyx_k_ROC), 0, 0, 1, 1},
-  {&__pyx_n_s_ROCP, __pyx_k_ROCP, sizeof(__pyx_k_ROCP), 0, 0, 1, 1},
-  {&__pyx_n_s_ROCR, __pyx_k_ROCR, sizeof(__pyx_k_ROCR), 0, 0, 1, 1},
-  {&__pyx_n_s_ROCR100, __pyx_k_ROCR100, sizeof(__pyx_k_ROCR100), 0, 0, 1, 1},
-  {&__pyx_n_s_RSI, __pyx_k_RSI, sizeof(__pyx_k_RSI), 0, 0, 1, 1},
-  {&__pyx_n_s_RangeType, __pyx_k_RangeType, sizeof(__pyx_k_RangeType), 0, 0, 1, 1},
-  {&__pyx_n_s_RealBody, __pyx_k_RealBody, sizeof(__pyx_k_RealBody), 0, 0, 1, 1},
-  {&__pyx_n_s_RuntimeError, __pyx_k_RuntimeError, sizeof(__pyx_k_RuntimeError), 0, 0, 1, 1},
-  {&__pyx_n_s_SAR, __pyx_k_SAR, sizeof(__pyx_k_SAR), 0, 0, 1, 1},
-  {&__pyx_n_s_SAREXT, __pyx_k_SAREXT, sizeof(__pyx_k_SAREXT), 0, 0, 1, 1},
-  {&__pyx_n_s_SIN, __pyx_k_SIN, sizeof(__pyx_k_SIN), 0, 0, 1, 1},
-  {&__pyx_n_s_SINH, __pyx_k_SINH, sizeof(__pyx_k_SINH), 0, 0, 1, 1},
-  {&__pyx_n_s_SMA, __pyx_k_SMA, sizeof(__pyx_k_SMA), 0, 0, 1, 1},
-  {&__pyx_n_s_SQRT, __pyx_k_SQRT, sizeof(__pyx_k_SQRT), 0, 0, 1, 1},
-  {&__pyx_n_s_STDDEV, __pyx_k_STDDEV, sizeof(__pyx_k_STDDEV), 0, 0, 1, 1},
-  {&__pyx_n_s_STOCH, __pyx_k_STOCH, sizeof(__pyx_k_STOCH), 0, 0, 1, 1},
-  {&__pyx_n_s_STOCHF, __pyx_k_STOCHF, sizeof(__pyx_k_STOCHF), 0, 0, 1, 1},
-  {&__pyx_n_s_STOCHRSI, __pyx_k_STOCHRSI, sizeof(__pyx_k_STOCHRSI), 0, 0, 1, 1},
-  {&__pyx_n_s_SUB, __pyx_k_SUB, sizeof(__pyx_k_SUB), 0, 0, 1, 1},
-  {&__pyx_n_s_SUM, __pyx_k_SUM, sizeof(__pyx_k_SUM), 0, 0, 1, 1},
-  {&__pyx_n_s_Series, __pyx_k_Series, sizeof(__pyx_k_Series), 0, 0, 1, 1},
-  {&__pyx_n_s_ShadowLong, __pyx_k_ShadowLong, sizeof(__pyx_k_ShadowLong), 0, 0, 1, 1},
-  {&__pyx_n_s_ShadowShort, __pyx_k_ShadowShort, sizeof(__pyx_k_ShadowShort), 0, 0, 1, 1},
-  {&__pyx_n_s_ShadowVeryLong, __pyx_k_ShadowVeryLong, sizeof(__pyx_k_ShadowVeryLong), 0, 0, 1, 1},
-  {&__pyx_n_s_ShadowVeryShort, __pyx_k_ShadowVeryShort, sizeof(__pyx_k_ShadowVeryShort), 0, 0, 1, 1},
-  {&__pyx_n_s_Shadows, __pyx_k_Shadows, sizeof(__pyx_k_Shadows), 0, 0, 1, 1},
-  {&__pyx_kp_s_Simple_Moving_Average, __pyx_k_Simple_Moving_Average, sizeof(__pyx_k_Simple_Moving_Average), 0, 0, 1, 0},
-  {&__pyx_kp_s_Strength_Pattern_200_100_Bearish, __pyx_k_Strength_Pattern_200_100_Bearish, sizeof(__pyx_k_Strength_Pattern_200_100_Bearish), 0, 0, 1, 0},
-  {&__pyx_n_s_T3, __pyx_k_T3, sizeof(__pyx_k_T3), 0, 0, 1, 1},
-  {&__pyx_n_s_TAN, __pyx_k_TAN, sizeof(__pyx_k_TAN), 0, 0, 1, 1},
-  {&__pyx_n_s_TANH, __pyx_k_TANH, sizeof(__pyx_k_TANH), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_ACOS, __pyx_k_TA_ACOS, sizeof(__pyx_k_TA_ACOS), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_AD, __pyx_k_TA_AD, sizeof(__pyx_k_TA_AD), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_ADD, __pyx_k_TA_ADD, sizeof(__pyx_k_TA_ADD), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_ADOSC, __pyx_k_TA_ADOSC, sizeof(__pyx_k_TA_ADOSC), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_ADX, __pyx_k_TA_ADX, sizeof(__pyx_k_TA_ADX), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_ADXR, __pyx_k_TA_ADXR, sizeof(__pyx_k_TA_ADXR), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_APO, __pyx_k_TA_APO, sizeof(__pyx_k_TA_APO), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_AROON, __pyx_k_TA_AROON, sizeof(__pyx_k_TA_AROON), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_AROONOSC, __pyx_k_TA_AROONOSC, sizeof(__pyx_k_TA_AROONOSC), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_ASIN, __pyx_k_TA_ASIN, sizeof(__pyx_k_TA_ASIN), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_ATAN, __pyx_k_TA_ATAN, sizeof(__pyx_k_TA_ATAN), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_ATR, __pyx_k_TA_ATR, sizeof(__pyx_k_TA_ATR), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_AVGPRICE, __pyx_k_TA_AVGPRICE, sizeof(__pyx_k_TA_AVGPRICE), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_BBANDS, __pyx_k_TA_BBANDS, sizeof(__pyx_k_TA_BBANDS), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_BETA, __pyx_k_TA_BETA, sizeof(__pyx_k_TA_BETA), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_BOP, __pyx_k_TA_BOP, sizeof(__pyx_k_TA_BOP), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_CCI, __pyx_k_TA_CCI, sizeof(__pyx_k_TA_CCI), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_CDL2CROWS, __pyx_k_TA_CDL2CROWS, sizeof(__pyx_k_TA_CDL2CROWS), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_CDL3BLACKCROWS, __pyx_k_TA_CDL3BLACKCROWS, sizeof(__pyx_k_TA_CDL3BLACKCROWS), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_CDL3INSIDE, __pyx_k_TA_CDL3INSIDE, sizeof(__pyx_k_TA_CDL3INSIDE), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_CDL3LINESTRIKE, __pyx_k_TA_CDL3LINESTRIKE, sizeof(__pyx_k_TA_CDL3LINESTRIKE), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_CDL3OUTSIDE, __pyx_k_TA_CDL3OUTSIDE, sizeof(__pyx_k_TA_CDL3OUTSIDE), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_CDL3STARSINSOUTH, __pyx_k_TA_CDL3STARSINSOUTH, sizeof(__pyx_k_TA_CDL3STARSINSOUTH), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_CDL3WHITESOLDIERS, __pyx_k_TA_CDL3WHITESOLDIERS, sizeof(__pyx_k_TA_CDL3WHITESOLDIERS), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_CDLABANDONEDBABY, __pyx_k_TA_CDLABANDONEDBABY, sizeof(__pyx_k_TA_CDLABANDONEDBABY), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_CDLADVANCEBLOCK, __pyx_k_TA_CDLADVANCEBLOCK, sizeof(__pyx_k_TA_CDLADVANCEBLOCK), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_CDLBELTHOLD, __pyx_k_TA_CDLBELTHOLD, sizeof(__pyx_k_TA_CDLBELTHOLD), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_CDLBREAKAWAY, __pyx_k_TA_CDLBREAKAWAY, sizeof(__pyx_k_TA_CDLBREAKAWAY), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_CDLCLOSINGMARUBOZU, __pyx_k_TA_CDLCLOSINGMARUBOZU, sizeof(__pyx_k_TA_CDLCLOSINGMARUBOZU), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_CDLCONCEALBABYSWALL, __pyx_k_TA_CDLCONCEALBABYSWALL, sizeof(__pyx_k_TA_CDLCONCEALBABYSWALL), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_CDLCOUNTERATTACK, __pyx_k_TA_CDLCOUNTERATTACK, sizeof(__pyx_k_TA_CDLCOUNTERATTACK), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_CDLDARKCLOUDCOVER, __pyx_k_TA_CDLDARKCLOUDCOVER, sizeof(__pyx_k_TA_CDLDARKCLOUDCOVER), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_CDLDOJI, __pyx_k_TA_CDLDOJI, sizeof(__pyx_k_TA_CDLDOJI), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_CDLDOJISTAR, __pyx_k_TA_CDLDOJISTAR, sizeof(__pyx_k_TA_CDLDOJISTAR), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_CDLDRAGONFLYDOJI, __pyx_k_TA_CDLDRAGONFLYDOJI, sizeof(__pyx_k_TA_CDLDRAGONFLYDOJI), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_CDLENGULFING, __pyx_k_TA_CDLENGULFING, sizeof(__pyx_k_TA_CDLENGULFING), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_CDLEVENINGDOJISTAR, __pyx_k_TA_CDLEVENINGDOJISTAR, sizeof(__pyx_k_TA_CDLEVENINGDOJISTAR), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_CDLEVENINGSTAR, __pyx_k_TA_CDLEVENINGSTAR, sizeof(__pyx_k_TA_CDLEVENINGSTAR), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_CDLGAPSIDESIDEWHITE, __pyx_k_TA_CDLGAPSIDESIDEWHITE, sizeof(__pyx_k_TA_CDLGAPSIDESIDEWHITE), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_CDLGRAVESTONEDOJI, __pyx_k_TA_CDLGRAVESTONEDOJI, sizeof(__pyx_k_TA_CDLGRAVESTONEDOJI), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_CDLHAMMER, __pyx_k_TA_CDLHAMMER, sizeof(__pyx_k_TA_CDLHAMMER), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_CDLHANGINGMAN, __pyx_k_TA_CDLHANGINGMAN, sizeof(__pyx_k_TA_CDLHANGINGMAN), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_CDLHARAMI, __pyx_k_TA_CDLHARAMI, sizeof(__pyx_k_TA_CDLHARAMI), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_CDLHARAMICROSS, __pyx_k_TA_CDLHARAMICROSS, sizeof(__pyx_k_TA_CDLHARAMICROSS), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_CDLHIGHWAVE, __pyx_k_TA_CDLHIGHWAVE, sizeof(__pyx_k_TA_CDLHIGHWAVE), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_CDLHIKKAKE, __pyx_k_TA_CDLHIKKAKE, sizeof(__pyx_k_TA_CDLHIKKAKE), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_CDLHIKKAKEMOD, __pyx_k_TA_CDLHIKKAKEMOD, sizeof(__pyx_k_TA_CDLHIKKAKEMOD), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_CDLHOMINGPIGEON, __pyx_k_TA_CDLHOMINGPIGEON, sizeof(__pyx_k_TA_CDLHOMINGPIGEON), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_CDLIDENTICAL3CROWS, __pyx_k_TA_CDLIDENTICAL3CROWS, sizeof(__pyx_k_TA_CDLIDENTICAL3CROWS), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_CDLINNECK, __pyx_k_TA_CDLINNECK, sizeof(__pyx_k_TA_CDLINNECK), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_CDLINVERTEDHAMMER, __pyx_k_TA_CDLINVERTEDHAMMER, sizeof(__pyx_k_TA_CDLINVERTEDHAMMER), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_CDLKICKING, __pyx_k_TA_CDLKICKING, sizeof(__pyx_k_TA_CDLKICKING), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_CDLKICKINGBYLENGTH, __pyx_k_TA_CDLKICKINGBYLENGTH, sizeof(__pyx_k_TA_CDLKICKINGBYLENGTH), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_CDLLADDERBOTTOM, __pyx_k_TA_CDLLADDERBOTTOM, sizeof(__pyx_k_TA_CDLLADDERBOTTOM), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_CDLLONGLEGGEDDOJI, __pyx_k_TA_CDLLONGLEGGEDDOJI, sizeof(__pyx_k_TA_CDLLONGLEGGEDDOJI), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_CDLLONGLINE, __pyx_k_TA_CDLLONGLINE, sizeof(__pyx_k_TA_CDLLONGLINE), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_CDLMARUBOZU, __pyx_k_TA_CDLMARUBOZU, sizeof(__pyx_k_TA_CDLMARUBOZU), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_CDLMATCHINGLOW, __pyx_k_TA_CDLMATCHINGLOW, sizeof(__pyx_k_TA_CDLMATCHINGLOW), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_CDLMATHOLD, __pyx_k_TA_CDLMATHOLD, sizeof(__pyx_k_TA_CDLMATHOLD), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_CDLMORNINGDOJISTAR, __pyx_k_TA_CDLMORNINGDOJISTAR, sizeof(__pyx_k_TA_CDLMORNINGDOJISTAR), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_CDLMORNINGSTAR, __pyx_k_TA_CDLMORNINGSTAR, sizeof(__pyx_k_TA_CDLMORNINGSTAR), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_CDLONNECK, __pyx_k_TA_CDLONNECK, sizeof(__pyx_k_TA_CDLONNECK), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_CDLPIERCING, __pyx_k_TA_CDLPIERCING, sizeof(__pyx_k_TA_CDLPIERCING), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_CDLRICKSHAWMAN, __pyx_k_TA_CDLRICKSHAWMAN, sizeof(__pyx_k_TA_CDLRICKSHAWMAN), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_CDLRISEFALL3METHODS, __pyx_k_TA_CDLRISEFALL3METHODS, sizeof(__pyx_k_TA_CDLRISEFALL3METHODS), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_CDLSEPARATINGLINES, __pyx_k_TA_CDLSEPARATINGLINES, sizeof(__pyx_k_TA_CDLSEPARATINGLINES), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_CDLSHOOTINGSTAR, __pyx_k_TA_CDLSHOOTINGSTAR, sizeof(__pyx_k_TA_CDLSHOOTINGSTAR), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_CDLSHORTLINE, __pyx_k_TA_CDLSHORTLINE, sizeof(__pyx_k_TA_CDLSHORTLINE), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_CDLSPINNINGTOP, __pyx_k_TA_CDLSPINNINGTOP, sizeof(__pyx_k_TA_CDLSPINNINGTOP), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_CDLSTALLEDPATTERN, __pyx_k_TA_CDLSTALLEDPATTERN, sizeof(__pyx_k_TA_CDLSTALLEDPATTERN), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_CDLSTICKSANDWICH, __pyx_k_TA_CDLSTICKSANDWICH, sizeof(__pyx_k_TA_CDLSTICKSANDWICH), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_CDLTAKURI, __pyx_k_TA_CDLTAKURI, sizeof(__pyx_k_TA_CDLTAKURI), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_CDLTASUKIGAP, __pyx_k_TA_CDLTASUKIGAP, sizeof(__pyx_k_TA_CDLTASUKIGAP), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_CDLTHRUSTING, __pyx_k_TA_CDLTHRUSTING, sizeof(__pyx_k_TA_CDLTHRUSTING), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_CDLTRISTAR, __pyx_k_TA_CDLTRISTAR, sizeof(__pyx_k_TA_CDLTRISTAR), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_CDLUNIQUE3RIVER, __pyx_k_TA_CDLUNIQUE3RIVER, sizeof(__pyx_k_TA_CDLUNIQUE3RIVER), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_CDLUPSIDEGAP2CROWS, __pyx_k_TA_CDLUPSIDEGAP2CROWS, sizeof(__pyx_k_TA_CDLUPSIDEGAP2CROWS), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_CDLXSIDEGAP3METHODS, __pyx_k_TA_CDLXSIDEGAP3METHODS, sizeof(__pyx_k_TA_CDLXSIDEGAP3METHODS), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_CEIL, __pyx_k_TA_CEIL, sizeof(__pyx_k_TA_CEIL), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_CMO, __pyx_k_TA_CMO, sizeof(__pyx_k_TA_CMO), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_CORREL, __pyx_k_TA_CORREL, sizeof(__pyx_k_TA_CORREL), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_COS, __pyx_k_TA_COS, sizeof(__pyx_k_TA_COS), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_COSH, __pyx_k_TA_COSH, sizeof(__pyx_k_TA_COSH), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_DEMA, __pyx_k_TA_DEMA, sizeof(__pyx_k_TA_DEMA), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_DIV, __pyx_k_TA_DIV, sizeof(__pyx_k_TA_DIV), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_DX, __pyx_k_TA_DX, sizeof(__pyx_k_TA_DX), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_EMA, __pyx_k_TA_EMA, sizeof(__pyx_k_TA_EMA), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_EXP, __pyx_k_TA_EXP, sizeof(__pyx_k_TA_EXP), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_FLOOR, __pyx_k_TA_FLOOR, sizeof(__pyx_k_TA_FLOOR), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_FUNCTION_NAMES, __pyx_k_TA_FUNCTION_NAMES, sizeof(__pyx_k_TA_FUNCTION_NAMES), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_FUNC_FLAGS, __pyx_k_TA_FUNC_FLAGS, sizeof(__pyx_k_TA_FUNC_FLAGS), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_FuncTableAlloc, __pyx_k_TA_FuncTableAlloc, sizeof(__pyx_k_TA_FuncTableAlloc), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_FuncTableFree, __pyx_k_TA_FuncTableFree, sizeof(__pyx_k_TA_FuncTableFree), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_GetFuncHandle, __pyx_k_TA_GetFuncHandle, sizeof(__pyx_k_TA_GetFuncHandle), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_GetFuncInfo, __pyx_k_TA_GetFuncInfo, sizeof(__pyx_k_TA_GetFuncInfo), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_GetInputParameterInfo, __pyx_k_TA_GetInputParameterInfo, sizeof(__pyx_k_TA_GetInputParameterInfo), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_GetLookback, __pyx_k_TA_GetLookback, sizeof(__pyx_k_TA_GetLookback), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_GetOptInputParameterInfo, __pyx_k_TA_GetOptInputParameterInfo, sizeof(__pyx_k_TA_GetOptInputParameterInfo), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_GetOutputParameterInfo, __pyx_k_TA_GetOutputParameterInfo, sizeof(__pyx_k_TA_GetOutputParameterInfo), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_GroupTableAlloc, __pyx_k_TA_GroupTableAlloc, sizeof(__pyx_k_TA_GroupTableAlloc), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_GroupTableFree, __pyx_k_TA_GroupTableFree, sizeof(__pyx_k_TA_GroupTableFree), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_HT_DCPERIOD, __pyx_k_TA_HT_DCPERIOD, sizeof(__pyx_k_TA_HT_DCPERIOD), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_HT_DCPHASE, __pyx_k_TA_HT_DCPHASE, sizeof(__pyx_k_TA_HT_DCPHASE), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_HT_PHASOR, __pyx_k_TA_HT_PHASOR, sizeof(__pyx_k_TA_HT_PHASOR), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_HT_SINE, __pyx_k_TA_HT_SINE, sizeof(__pyx_k_TA_HT_SINE), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_HT_TRENDLINE, __pyx_k_TA_HT_TRENDLINE, sizeof(__pyx_k_TA_HT_TRENDLINE), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_HT_TRENDMODE, __pyx_k_TA_HT_TRENDMODE, sizeof(__pyx_k_TA_HT_TRENDMODE), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_INPUT_FLAGS, __pyx_k_TA_INPUT_FLAGS, sizeof(__pyx_k_TA_INPUT_FLAGS), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_Initialize, __pyx_k_TA_Initialize, sizeof(__pyx_k_TA_Initialize), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_KAMA, __pyx_k_TA_KAMA, sizeof(__pyx_k_TA_KAMA), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_LINEARREG, __pyx_k_TA_LINEARREG, sizeof(__pyx_k_TA_LINEARREG), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_LINEARREG_ANGLE, __pyx_k_TA_LINEARREG_ANGLE, sizeof(__pyx_k_TA_LINEARREG_ANGLE), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_LINEARREG_INTERCEPT, __pyx_k_TA_LINEARREG_INTERCEPT, sizeof(__pyx_k_TA_LINEARREG_INTERCEPT), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_LINEARREG_SLOPE, __pyx_k_TA_LINEARREG_SLOPE, sizeof(__pyx_k_TA_LINEARREG_SLOPE), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_LN, __pyx_k_TA_LN, sizeof(__pyx_k_TA_LN), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_LOG10, __pyx_k_TA_LOG10, sizeof(__pyx_k_TA_LOG10), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_MA, __pyx_k_TA_MA, sizeof(__pyx_k_TA_MA), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_MACD, __pyx_k_TA_MACD, sizeof(__pyx_k_TA_MACD), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_MACDEXT, __pyx_k_TA_MACDEXT, sizeof(__pyx_k_TA_MACDEXT), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_MACDFIX, __pyx_k_TA_MACDFIX, sizeof(__pyx_k_TA_MACDFIX), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_MAMA, __pyx_k_TA_MAMA, sizeof(__pyx_k_TA_MAMA), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_MAVP, __pyx_k_TA_MAVP, sizeof(__pyx_k_TA_MAVP), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_MAX, __pyx_k_TA_MAX, sizeof(__pyx_k_TA_MAX), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_MAXINDEX, __pyx_k_TA_MAXINDEX, sizeof(__pyx_k_TA_MAXINDEX), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_MEDPRICE, __pyx_k_TA_MEDPRICE, sizeof(__pyx_k_TA_MEDPRICE), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_MFI, __pyx_k_TA_MFI, sizeof(__pyx_k_TA_MFI), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_MIDPOINT, __pyx_k_TA_MIDPOINT, sizeof(__pyx_k_TA_MIDPOINT), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_MIDPRICE, __pyx_k_TA_MIDPRICE, sizeof(__pyx_k_TA_MIDPRICE), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_MIN, __pyx_k_TA_MIN, sizeof(__pyx_k_TA_MIN), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_MININDEX, __pyx_k_TA_MININDEX, sizeof(__pyx_k_TA_MININDEX), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_MINMAX, __pyx_k_TA_MINMAX, sizeof(__pyx_k_TA_MINMAX), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_MINMAXINDEX, __pyx_k_TA_MINMAXINDEX, sizeof(__pyx_k_TA_MINMAXINDEX), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_MINUS_DI, __pyx_k_TA_MINUS_DI, sizeof(__pyx_k_TA_MINUS_DI), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_MINUS_DM, __pyx_k_TA_MINUS_DM, sizeof(__pyx_k_TA_MINUS_DM), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_MOM, __pyx_k_TA_MOM, sizeof(__pyx_k_TA_MOM), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_MULT, __pyx_k_TA_MULT, sizeof(__pyx_k_TA_MULT), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_NATR, __pyx_k_TA_NATR, sizeof(__pyx_k_TA_NATR), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_OBV, __pyx_k_TA_OBV, sizeof(__pyx_k_TA_OBV), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_OUTPUT_FLAGS, __pyx_k_TA_OUTPUT_FLAGS, sizeof(__pyx_k_TA_OUTPUT_FLAGS), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_PLUS_DI, __pyx_k_TA_PLUS_DI, sizeof(__pyx_k_TA_PLUS_DI), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_PLUS_DM, __pyx_k_TA_PLUS_DM, sizeof(__pyx_k_TA_PLUS_DM), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_PPO, __pyx_k_TA_PPO, sizeof(__pyx_k_TA_PPO), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_ParamHolderAlloc, __pyx_k_TA_ParamHolderAlloc, sizeof(__pyx_k_TA_ParamHolderAlloc), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_ParamHolderFree, __pyx_k_TA_ParamHolderFree, sizeof(__pyx_k_TA_ParamHolderFree), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_ROC, __pyx_k_TA_ROC, sizeof(__pyx_k_TA_ROC), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_ROCP, __pyx_k_TA_ROCP, sizeof(__pyx_k_TA_ROCP), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_ROCR, __pyx_k_TA_ROCR, sizeof(__pyx_k_TA_ROCR), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_ROCR100, __pyx_k_TA_ROCR100, sizeof(__pyx_k_TA_ROCR100), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_RSI, __pyx_k_TA_RSI, sizeof(__pyx_k_TA_RSI), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_RestoreCandleDefaultSettings, __pyx_k_TA_RestoreCandleDefaultSettings, sizeof(__pyx_k_TA_RestoreCandleDefaultSettings), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_SAR, __pyx_k_TA_SAR, sizeof(__pyx_k_TA_SAR), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_SAREXT, __pyx_k_TA_SAREXT, sizeof(__pyx_k_TA_SAREXT), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_SIN, __pyx_k_TA_SIN, sizeof(__pyx_k_TA_SIN), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_SINH, __pyx_k_TA_SINH, sizeof(__pyx_k_TA_SINH), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_SMA, __pyx_k_TA_SMA, sizeof(__pyx_k_TA_SMA), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_SQRT, __pyx_k_TA_SQRT, sizeof(__pyx_k_TA_SQRT), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_STDDEV, __pyx_k_TA_STDDEV, sizeof(__pyx_k_TA_STDDEV), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_STOCH, __pyx_k_TA_STOCH, sizeof(__pyx_k_TA_STOCH), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_STOCHF, __pyx_k_TA_STOCHF, sizeof(__pyx_k_TA_STOCHF), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_STOCHRSI, __pyx_k_TA_STOCHRSI, sizeof(__pyx_k_TA_STOCHRSI), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_SUB, __pyx_k_TA_SUB, sizeof(__pyx_k_TA_SUB), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_SUM, __pyx_k_TA_SUM, sizeof(__pyx_k_TA_SUM), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_SetCandleSettings, __pyx_k_TA_SetCandleSettings, sizeof(__pyx_k_TA_SetCandleSettings), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_SetCompatibility, __pyx_k_TA_SetCompatibility, sizeof(__pyx_k_TA_SetCompatibility), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_SetOptInputParamInteger, __pyx_k_TA_SetOptInputParamInteger, sizeof(__pyx_k_TA_SetOptInputParamInteger), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_SetOptInputParamReal, __pyx_k_TA_SetOptInputParamReal, sizeof(__pyx_k_TA_SetOptInputParamReal), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_SetUnstablePeriod, __pyx_k_TA_SetUnstablePeriod, sizeof(__pyx_k_TA_SetUnstablePeriod), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_Shutdown, __pyx_k_TA_Shutdown, sizeof(__pyx_k_TA_Shutdown), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_T3, __pyx_k_TA_T3, sizeof(__pyx_k_TA_T3), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_TAN, __pyx_k_TA_TAN, sizeof(__pyx_k_TA_TAN), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_TANH, __pyx_k_TA_TANH, sizeof(__pyx_k_TA_TANH), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_TEMA, __pyx_k_TA_TEMA, sizeof(__pyx_k_TA_TEMA), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_TRANGE, __pyx_k_TA_TRANGE, sizeof(__pyx_k_TA_TRANGE), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_TRIMA, __pyx_k_TA_TRIMA, sizeof(__pyx_k_TA_TRIMA), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_TRIX, __pyx_k_TA_TRIX, sizeof(__pyx_k_TA_TRIX), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_TSF, __pyx_k_TA_TSF, sizeof(__pyx_k_TA_TSF), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_TYPPRICE, __pyx_k_TA_TYPPRICE, sizeof(__pyx_k_TA_TYPPRICE), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_ULTOSC, __pyx_k_TA_ULTOSC, sizeof(__pyx_k_TA_ULTOSC), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_VAR, __pyx_k_TA_VAR, sizeof(__pyx_k_TA_VAR), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_WCLPRICE, __pyx_k_TA_WCLPRICE, sizeof(__pyx_k_TA_WCLPRICE), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_WILLR, __pyx_k_TA_WILLR, sizeof(__pyx_k_TA_WILLR), 0, 0, 1, 1},
-  {&__pyx_n_s_TA_WMA, __pyx_k_TA_WMA, sizeof(__pyx_k_TA_WMA), 0, 0, 1, 1},
-  {&__pyx_n_s_TEMA, __pyx_k_TEMA, sizeof(__pyx_k_TEMA), 0, 0, 1, 1},
-  {&__pyx_n_s_TRANGE, __pyx_k_TRANGE, sizeof(__pyx_k_TRANGE), 0, 0, 1, 1},
-  {&__pyx_n_s_TRIMA, __pyx_k_TRIMA, sizeof(__pyx_k_TRIMA), 0, 0, 1, 1},
-  {&__pyx_n_s_TRIX, __pyx_k_TRIX, sizeof(__pyx_k_TRIX), 0, 0, 1, 1},
-  {&__pyx_n_s_TSF, __pyx_k_TSF, sizeof(__pyx_k_TSF), 0, 0, 1, 1},
-  {&__pyx_n_s_TYPPRICE, __pyx_k_TYPPRICE, sizeof(__pyx_k_TYPPRICE), 0, 0, 1, 1},
-  {&__pyx_kp_s_This_is_a_pythonic_wrapper_arou, __pyx_k_This_is_a_pythonic_wrapper_arou, sizeof(__pyx_k_This_is_a_pythonic_wrapper_arou), 0, 0, 1, 0},
-  {&__pyx_kp_s_Too_many_price_arguments_expecte, __pyx_k_Too_many_price_arguments_expecte, sizeof(__pyx_k_Too_many_price_arguments_expecte), 0, 0, 1, 0},
-  {&__pyx_kp_s_Triangular_Moving_Average, __pyx_k_Triangular_Moving_Average, sizeof(__pyx_k_Triangular_Moving_Average), 0, 0, 1, 0},
-  {&__pyx_kp_s_Triple_Exponential_Moving_Averag, __pyx_k_Triple_Exponential_Moving_Averag, sizeof(__pyx_k_Triple_Exponential_Moving_Averag), 0, 0, 1, 0},
-  {&__pyx_kp_s_Triple_Generalized_Double_Expone, __pyx_k_Triple_Generalized_Double_Expone, sizeof(__pyx_k_Triple_Generalized_Double_Expone), 0, 0, 1, 0},
-  {&__pyx_n_s_TypeError, __pyx_k_TypeError, sizeof(__pyx_k_TypeError), 0, 0, 1, 1},
-  {&__pyx_n_s_ULTOSC, __pyx_k_ULTOSC, sizeof(__pyx_k_ULTOSC), 0, 0, 1, 1},
-  {&__pyx_kp_s_Unknown_Error, __pyx_k_Unknown_Error, sizeof(__pyx_k_Unknown_Error), 0, 0, 1, 0},
-  {&__pyx_kp_s_Unknown_Error_TA_UNKNOWN_ERR, __pyx_k_Unknown_Error_TA_UNKNOWN_ERR, sizeof(__pyx_k_Unknown_Error_TA_UNKNOWN_ERR), 0, 0, 1, 0},
-  {&__pyx_n_s_VAR, __pyx_k_VAR, sizeof(__pyx_k_VAR), 0, 0, 1, 1},
-  {&__pyx_n_s_ValueError, __pyx_k_ValueError, sizeof(__pyx_k_ValueError), 0, 0, 1, 1},
-  {&__pyx_kp_s_Values_represent_a_lower_limit, __pyx_k_Values_represent_a_lower_limit, sizeof(__pyx_k_Values_represent_a_lower_limit), 0, 0, 1, 0},
-  {&__pyx_kp_s_Values_represent_an_upper_limit, __pyx_k_Values_represent_an_upper_limit, sizeof(__pyx_k_Values_represent_an_upper_limit), 0, 0, 1, 0},
-  {&__pyx_n_s_WCLPRICE, __pyx_k_WCLPRICE, sizeof(__pyx_k_WCLPRICE), 0, 0, 1, 1},
-  {&__pyx_n_s_WILLR, __pyx_k_WILLR, sizeof(__pyx_k_WILLR), 0, 0, 1, 1},
-  {&__pyx_n_s_WMA, __pyx_k_WMA, sizeof(__pyx_k_WMA), 0, 0, 1, 1},
-  {&__pyx_kp_s_Weighted_Moving_Average, __pyx_k_Weighted_Moving_Average, sizeof(__pyx_k_Weighted_Moving_Average), 0, 0, 1, 0},
-  {&__pyx_kp_s__10, __pyx_k__10, sizeof(__pyx_k__10), 0, 0, 1, 0},
-  {&__pyx_kp_s__11, __pyx_k__11, sizeof(__pyx_k__11), 0, 0, 1, 0},
-  {&__pyx_kp_s__5, __pyx_k__5, sizeof(__pyx_k__5), 0, 0, 1, 0},
-  {&__pyx_kp_s__6, __pyx_k__6, sizeof(__pyx_k__6), 0, 0, 1, 0},
-  {&__pyx_kp_s__8, __pyx_k__8, sizeof(__pyx_k__8), 0, 0, 1, 0},
-  {&__pyx_kp_s__9, __pyx_k__9, sizeof(__pyx_k__9), 0, 0, 1, 0},
-  {&__pyx_n_s_acceleration, __pyx_k_acceleration, sizeof(__pyx_k_acceleration), 0, 0, 1, 1},
-  {&__pyx_n_s_accelerationinitlong, __pyx_k_accelerationinitlong, sizeof(__pyx_k_accelerationinitlong), 0, 0, 1, 1},
-  {&__pyx_n_s_accelerationinitshort, __pyx_k_accelerationinitshort, sizeof(__pyx_k_accelerationinitshort), 0, 0, 1, 1},
-  {&__pyx_n_s_accelerationlong, __pyx_k_accelerationlong, sizeof(__pyx_k_accelerationlong), 0, 0, 1, 1},
-  {&__pyx_n_s_accelerationmaxlong, __pyx_k_accelerationmaxlong, sizeof(__pyx_k_accelerationmaxlong), 0, 0, 1, 1},
-  {&__pyx_n_s_accelerationmaxshort, __pyx_k_accelerationmaxshort, sizeof(__pyx_k_accelerationmaxshort), 0, 0, 1, 1},
-  {&__pyx_n_s_accelerationshort, __pyx_k_accelerationshort, sizeof(__pyx_k_accelerationshort), 0, 0, 1, 1},
-  {&__pyx_kp_s_any_ndarray, __pyx_k_any_ndarray, sizeof(__pyx_k_any_ndarray), 0, 0, 1, 0},
-  {&__pyx_n_s_arg, __pyx_k_arg, sizeof(__pyx_k_arg), 0, 0, 1, 1},
-  {&__pyx_n_s_args, __pyx_k_args, sizeof(__pyx_k_args), 0, 0, 1, 1},
-  {&__pyx_n_s_ascii, __pyx_k_ascii, sizeof(__pyx_k_ascii), 0, 0, 1, 1},
-  {&__pyx_n_s_astype, __pyx_k_astype, sizeof(__pyx_k_astype), 0, 0, 1, 1},
-  {&__pyx_n_s_avgperiod, __pyx_k_avgperiod, sizeof(__pyx_k_avgperiod), 0, 0, 1, 1},
-  {&__pyx_n_s_b, __pyx_k_b, sizeof(__pyx_k_b), 0, 0, 1, 1},
-  {&__pyx_n_s_begidx, __pyx_k_begidx, sizeof(__pyx_k_begidx), 0, 0, 1, 1},
-  {&__pyx_n_s_bytes2str, __pyx_k_bytes2str, sizeof(__pyx_k_bytes2str), 0, 0, 1, 1},
-  {&__pyx_n_s_call, __pyx_k_call, sizeof(__pyx_k_call), 0, 0, 1, 1},
-  {&__pyx_n_s_call_function, __pyx_k_call_function, sizeof(__pyx_k_call_function), 0, 0, 1, 1},
-  {&__pyx_n_s_check_opt_input_value, __pyx_k_check_opt_input_value, sizeof(__pyx_k_check_opt_input_value), 0, 0, 1, 1},
-  {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1},
-  {&__pyx_n_s_close, __pyx_k_close, sizeof(__pyx_k_close), 0, 0, 1, 1},
-  {&__pyx_n_s_close_data, __pyx_k_close_data, sizeof(__pyx_k_close_data), 0, 0, 1, 1},
-  {&__pyx_n_s_collections, __pyx_k_collections, sizeof(__pyx_k_collections), 0, 0, 1, 1},
-  {&__pyx_n_s_column_stack, __pyx_k_column_stack, sizeof(__pyx_k_column_stack), 0, 0, 1, 1},
-  {&__pyx_n_s_columns, __pyx_k_columns, sizeof(__pyx_k_columns), 0, 0, 1, 1},
-  {&__pyx_n_s_copy, __pyx_k_copy, sizeof(__pyx_k_copy), 0, 0, 1, 1},
-  {&__pyx_n_s_decode, __pyx_k_decode, sizeof(__pyx_k_decode), 0, 0, 1, 1},
-  {&__pyx_n_s_default_value, __pyx_k_default_value, sizeof(__pyx_k_default_value), 0, 0, 1, 1},
-  {&__pyx_n_s_defaults, __pyx_k_defaults, sizeof(__pyx_k_defaults), 0, 0, 1, 1},
-  {&__pyx_n_s_display_name, __pyx_k_display_name, sizeof(__pyx_k_display_name), 0, 0, 1, 1},
-  {&__pyx_kp_s_display_name_s_group_s, __pyx_k_display_name_s_group_s, sizeof(__pyx_k_display_name_s_group_s), 0, 0, 1, 0},
-  {&__pyx_n_s_doc, __pyx_k_doc, sizeof(__pyx_k_doc), 0, 0, 1, 1},
-  {&__pyx_n_s_docs, __pyx_k_docs, sizeof(__pyx_k_docs), 0, 0, 1, 1},
-  {&__pyx_n_s_documentation, __pyx_k_documentation, sizeof(__pyx_k_documentation), 0, 0, 1, 1},
-  {&__pyx_n_s_endidx, __pyx_k_endidx, sizeof(__pyx_k_endidx), 0, 0, 1, 1},
-  {&__pyx_n_s_enumerate, __pyx_k_enumerate, sizeof(__pyx_k_enumerate), 0, 0, 1, 1},
-  {&__pyx_n_s_factor, __pyx_k_factor, sizeof(__pyx_k_factor), 0, 0, 1, 1},
-  {&__pyx_n_s_fastd_matype, __pyx_k_fastd_matype, sizeof(__pyx_k_fastd_matype), 0, 0, 1, 1},
-  {&__pyx_n_s_fastd_period, __pyx_k_fastd_period, sizeof(__pyx_k_fastd_period), 0, 0, 1, 1},
-  {&__pyx_n_s_fastk_period, __pyx_k_fastk_period, sizeof(__pyx_k_fastk_period), 0, 0, 1, 1},
-  {&__pyx_n_s_fastlimit, __pyx_k_fastlimit, sizeof(__pyx_k_fastlimit), 0, 0, 1, 1},
-  {&__pyx_n_s_fastmatype, __pyx_k_fastmatype, sizeof(__pyx_k_fastmatype), 0, 0, 1, 1},
-  {&__pyx_n_s_fastperiod, __pyx_k_fastperiod, sizeof(__pyx_k_fastperiod), 0, 0, 1, 1},
-  {&__pyx_n_s_flag, __pyx_k_flag, sizeof(__pyx_k_flag), 0, 0, 1, 1},
-  {&__pyx_n_s_flags, __pyx_k_flags, sizeof(__pyx_k_flags), 0, 0, 1, 1},
-  {&__pyx_n_s_flags_lookup_dict, __pyx_k_flags_lookup_dict, sizeof(__pyx_k_flags_lookup_dict), 0, 0, 1, 1},
-  {&__pyx_n_s_func_args, __pyx_k_func_args, sizeof(__pyx_k_func_args), 0, 0, 1, 1},
-  {&__pyx_n_s_func_info, __pyx_k_func_info, sizeof(__pyx_k_func_info), 0, 0, 1, 1},
-  {&__pyx_n_s_func_line, __pyx_k_func_line, sizeof(__pyx_k_func_line), 0, 0, 1, 1},
-  {&__pyx_n_s_func_object, __pyx_k_func_object, sizeof(__pyx_k_func_object), 0, 0, 1, 1},
-  {&__pyx_n_s_function_flags, __pyx_k_function_flags, sizeof(__pyx_k_function_flags), 0, 0, 1, 1},
-  {&__pyx_n_s_function_name, __pyx_k_function_name, sizeof(__pyx_k_function_name), 0, 0, 1, 1},
-  {&__pyx_n_s_functions, __pyx_k_functions, sizeof(__pyx_k_functions), 0, 0, 1, 1},
-  {&__pyx_n_s_get_defaults_and_docs, __pyx_k_get_defaults_and_docs, sizeof(__pyx_k_get_defaults_and_docs), 0, 0, 1, 1},
-  {&__pyx_n_s_get_flags, __pyx_k_get_flags, sizeof(__pyx_k_get_flags), 0, 0, 1, 1},
-  {&__pyx_n_s_get_input_arrays, __pyx_k_get_input_arrays, sizeof(__pyx_k_get_input_arrays), 0, 0, 1, 1},
-  {&__pyx_n_s_get_input_names, __pyx_k_get_input_names, sizeof(__pyx_k_get_input_names), 0, 0, 1, 1},
-  {&__pyx_n_s_get_opt_input_value, __pyx_k_get_opt_input_value, sizeof(__pyx_k_get_opt_input_value), 0, 0, 1, 1},
-  {&__pyx_n_s_get_parameters, __pyx_k_get_parameters, sizeof(__pyx_k_get_parameters), 0, 0, 1, 1},
-  {&__pyx_n_s_getitem, __pyx_k_getitem, sizeof(__pyx_k_getitem), 0, 0, 1, 1},
-  {&__pyx_n_s_group, __pyx_k_group, sizeof(__pyx_k_group), 0, 0, 1, 1},
-  {&__pyx_n_s_groups, __pyx_k_groups, sizeof(__pyx_k_groups), 0, 0, 1, 1},
-  {&__pyx_n_s_help, __pyx_k_help, sizeof(__pyx_k_help), 0, 0, 1, 1},
-  {&__pyx_n_s_high, __pyx_k_high, sizeof(__pyx_k_high), 0, 0, 1, 1},
-  {&__pyx_n_s_high_data, __pyx_k_high_data, sizeof(__pyx_k_high_data), 0, 0, 1, 1},
-  {&__pyx_n_s_holder, __pyx_k_holder, sizeof(__pyx_k_holder), 0, 0, 1, 1},
-  {&__pyx_n_s_i, __pyx_k_i, sizeof(__pyx_k_i), 0, 0, 1, 1},
-  {&__pyx_n_s_id, __pyx_k_id, sizeof(__pyx_k_id), 0, 0, 1, 1},
-  {&__pyx_n_s_idx, __pyx_k_idx, sizeof(__pyx_k_idx), 0, 0, 1, 1},
-  {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1},
-  {&__pyx_n_s_in, __pyx_k_in, sizeof(__pyx_k_in), 0, 0, 1, 1},
-  {&__pyx_n_s_index, __pyx_k_index, sizeof(__pyx_k_index), 0, 0, 1, 1},
-  {&__pyx_n_s_info, __pyx_k_info, sizeof(__pyx_k_info), 0, 0, 1, 1},
-  {&__pyx_n_s_init, __pyx_k_init, sizeof(__pyx_k_init), 0, 0, 1, 1},
-  {&__pyx_n_s_initialize_function_info, __pyx_k_initialize_function_info, sizeof(__pyx_k_initialize_function_info), 0, 0, 1, 1},
-  {&__pyx_kp_s_input_array_has_wrong_dimensions, __pyx_k_input_array_has_wrong_dimensions, sizeof(__pyx_k_input_array_has_wrong_dimensions), 0, 0, 1, 0},
-  {&__pyx_kp_s_input_array_lengths_are_differen, __pyx_k_input_array_lengths_are_differen, sizeof(__pyx_k_input_array_lengths_are_differen), 0, 0, 1, 0},
-  {&__pyx_kp_s_input_array_type_is_not_double, __pyx_k_input_array_type_is_not_double, sizeof(__pyx_k_input_array_type_is_not_double), 0, 0, 1, 0},
-  {&__pyx_n_s_input_arrays, __pyx_k_input_arrays, sizeof(__pyx_k_input_arrays), 0, 0, 1, 1},
-  {&__pyx_kp_s_input_arrays_2, __pyx_k_input_arrays_2, sizeof(__pyx_k_input_arrays_2), 0, 0, 1, 0},
-  {&__pyx_kp_s_input_arrays_parameter_missing_r, __pyx_k_input_arrays_parameter_missing_r, sizeof(__pyx_k_input_arrays_parameter_missing_r), 0, 0, 1, 0},
-  {&__pyx_n_s_input_name, __pyx_k_input_name, sizeof(__pyx_k_input_name), 0, 0, 1, 1},
-  {&__pyx_n_s_input_names, __pyx_k_input_names, sizeof(__pyx_k_input_names), 0, 0, 1, 1},
-  {&__pyx_n_s_input_price_series_names, __pyx_k_input_price_series_names, sizeof(__pyx_k_input_price_series_names), 0, 0, 1, 1},
-  {&__pyx_n_s_input_price_series_names_2, __pyx_k_input_price_series_names_2, sizeof(__pyx_k_input_price_series_names_2), 0, 0, 1, 1},
-  {&__pyx_kp_s_inputs_are_all_NaN, __pyx_k_inputs_are_all_NaN, sizeof(__pyx_k_inputs_are_all_NaN), 0, 0, 1, 0},
-  {&__pyx_n_s_integer, __pyx_k_integer, sizeof(__pyx_k_integer), 0, 0, 1, 1},
-  {&__pyx_kp_s_integer_values_are_100_0_or_100, __pyx_k_integer_values_are_100_0_or_100, sizeof(__pyx_k_integer_values_are_100_0_or_100), 0, 0, 1, 0},
-  {&__pyx_n_s_items, __pyx_k_items, sizeof(__pyx_k_items), 0, 0, 1, 1},
-  {&__pyx_n_s_join, __pyx_k_join, sizeof(__pyx_k_join), 0, 0, 1, 1},
-  {&__pyx_n_s_key, __pyx_k_key, sizeof(__pyx_k_key), 0, 0, 1, 1},
-  {&__pyx_n_s_keys, __pyx_k_keys, sizeof(__pyx_k_keys), 0, 0, 1, 1},
-  {&__pyx_n_s_kwargs, __pyx_k_kwargs, sizeof(__pyx_k_kwargs), 0, 0, 1, 1},
-  {&__pyx_n_s_length, __pyx_k_length, sizeof(__pyx_k_length), 0, 0, 1, 1},
-  {&__pyx_n_s_log, __pyx_k_log, sizeof(__pyx_k_log), 0, 0, 1, 1},
-  {&__pyx_n_s_lookback, __pyx_k_lookback, sizeof(__pyx_k_lookback), 0, 0, 1, 1},
-  {&__pyx_n_s_lookup, __pyx_k_lookup, sizeof(__pyx_k_lookup), 0, 0, 1, 1},
-  {&__pyx_n_s_low, __pyx_k_low, sizeof(__pyx_k_low), 0, 0, 1, 1},
-  {&__pyx_n_s_low_data, __pyx_k_low_data, sizeof(__pyx_k_low_data), 0, 0, 1, 1},
-  {&__pyx_n_s_lower, __pyx_k_lower, sizeof(__pyx_k_lower), 0, 0, 1, 1},
-  {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1},
-  {&__pyx_n_s_math, __pyx_k_math, sizeof(__pyx_k_math), 0, 0, 1, 1},
-  {&__pyx_n_s_matype, __pyx_k_matype, sizeof(__pyx_k_matype), 0, 0, 1, 1},
-  {&__pyx_n_s_max, __pyx_k_max, sizeof(__pyx_k_max), 0, 0, 1, 1},
-  {&__pyx_n_s_max_int, __pyx_k_max_int, sizeof(__pyx_k_max_int), 0, 0, 1, 1},
-  {&__pyx_n_s_maximum, __pyx_k_maximum, sizeof(__pyx_k_maximum), 0, 0, 1, 1},
-  {&__pyx_n_s_maxperiod, __pyx_k_maxperiod, sizeof(__pyx_k_maxperiod), 0, 0, 1, 1},
-  {&__pyx_n_s_metaclass, __pyx_k_metaclass, sizeof(__pyx_k_metaclass), 0, 0, 1, 1},
-  {&__pyx_n_s_min, __pyx_k_min, sizeof(__pyx_k_min), 0, 0, 1, 1},
-  {&__pyx_n_s_min_int, __pyx_k_min_int, sizeof(__pyx_k_min_int), 0, 0, 1, 1},
-  {&__pyx_n_s_minperiod, __pyx_k_minperiod, sizeof(__pyx_k_minperiod), 0, 0, 1, 1},
-  {&__pyx_n_s_missing_keys, __pyx_k_missing_keys, sizeof(__pyx_k_missing_keys), 0, 0, 1, 1},
-  {&__pyx_n_s_module, __pyx_k_module, sizeof(__pyx_k_module), 0, 0, 1, 1},
-  {&__pyx_n_s_msg, __pyx_k_msg, sizeof(__pyx_k_msg), 0, 0, 1, 1},
-  {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1},
-  {&__pyx_n_s_name_2, __pyx_k_name_2, sizeof(__pyx_k_name_2), 0, 0, 1, 1},
-  {&__pyx_n_s_nan, __pyx_k_nan, sizeof(__pyx_k_nan), 0, 0, 1, 1},
-  {&__pyx_n_s_nbdev, __pyx_k_nbdev, sizeof(__pyx_k_nbdev), 0, 0, 1, 1},
-  {&__pyx_n_s_nbdevdn, __pyx_k_nbdevdn, sizeof(__pyx_k_nbdevdn), 0, 0, 1, 1},
-  {&__pyx_n_s_nbdevup, __pyx_k_nbdevup, sizeof(__pyx_k_nbdevup), 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_num_inputs, __pyx_k_num_inputs, sizeof(__pyx_k_num_inputs), 0, 0, 1, 1},
-  {&__pyx_n_s_num_opt_inputs, __pyx_k_num_opt_inputs, sizeof(__pyx_k_num_opt_inputs), 0, 0, 1, 1},
-  {&__pyx_n_s_num_outputs, __pyx_k_num_outputs, sizeof(__pyx_k_num_outputs), 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_object, __pyx_k_object, sizeof(__pyx_k_object), 0, 0, 1, 1},
-  {&__pyx_n_s_offsetonreverse, __pyx_k_offsetonreverse, sizeof(__pyx_k_offsetonreverse), 0, 0, 1, 1},
-  {&__pyx_n_s_open, __pyx_k_open, sizeof(__pyx_k_open), 0, 0, 1, 1},
-  {&__pyx_n_s_openInterest, __pyx_k_openInterest, sizeof(__pyx_k_openInterest), 0, 0, 1, 1},
-  {&__pyx_n_s_open_data, __pyx_k_open_data, sizeof(__pyx_k_open_data), 0, 0, 1, 1},
-  {&__pyx_n_s_optIn, __pyx_k_optIn, sizeof(__pyx_k_optIn), 0, 0, 1, 1},
-  {&__pyx_n_s_opt_input, __pyx_k_opt_input, sizeof(__pyx_k_opt_input), 0, 0, 1, 1},
-  {&__pyx_n_s_opt_input_values, __pyx_k_opt_input_values, sizeof(__pyx_k_opt_input_values), 0, 0, 1, 1},
-  {&__pyx_n_s_ordereddict, __pyx_k_ordereddict, sizeof(__pyx_k_ordereddict), 0, 0, 1, 1},
-  {&__pyx_n_s_out, __pyx_k_out, sizeof(__pyx_k_out), 0, 0, 1, 1},
-  {&__pyx_n_s_outaroondown, __pyx_k_outaroondown, sizeof(__pyx_k_outaroondown), 0, 0, 1, 1},
-  {&__pyx_n_s_outaroonup, __pyx_k_outaroonup, sizeof(__pyx_k_outaroonup), 0, 0, 1, 1},
-  {&__pyx_n_s_outbegidx, __pyx_k_outbegidx, sizeof(__pyx_k_outbegidx), 0, 0, 1, 1},
-  {&__pyx_n_s_outfama, __pyx_k_outfama, sizeof(__pyx_k_outfama), 0, 0, 1, 1},
-  {&__pyx_n_s_outfastd, __pyx_k_outfastd, sizeof(__pyx_k_outfastd), 0, 0, 1, 1},
-  {&__pyx_n_s_outfastk, __pyx_k_outfastk, sizeof(__pyx_k_outfastk), 0, 0, 1, 1},
-  {&__pyx_n_s_outinphase, __pyx_k_outinphase, sizeof(__pyx_k_outinphase), 0, 0, 1, 1},
-  {&__pyx_n_s_outinteger, __pyx_k_outinteger, sizeof(__pyx_k_outinteger), 0, 0, 1, 1},
-  {&__pyx_n_s_outleadsine, __pyx_k_outleadsine, sizeof(__pyx_k_outleadsine), 0, 0, 1, 1},
-  {&__pyx_n_s_outmacd, __pyx_k_outmacd, sizeof(__pyx_k_outmacd), 0, 0, 1, 1},
-  {&__pyx_n_s_outmacdhist, __pyx_k_outmacdhist, sizeof(__pyx_k_outmacdhist), 0, 0, 1, 1},
-  {&__pyx_n_s_outmacdsignal, __pyx_k_outmacdsignal, sizeof(__pyx_k_outmacdsignal), 0, 0, 1, 1},
-  {&__pyx_n_s_outmama, __pyx_k_outmama, sizeof(__pyx_k_outmama), 0, 0, 1, 1},
-  {&__pyx_n_s_outmax, __pyx_k_outmax, sizeof(__pyx_k_outmax), 0, 0, 1, 1},
-  {&__pyx_n_s_outmaxidx, __pyx_k_outmaxidx, sizeof(__pyx_k_outmaxidx), 0, 0, 1, 1},
-  {&__pyx_n_s_outmin, __pyx_k_outmin, sizeof(__pyx_k_outmin), 0, 0, 1, 1},
-  {&__pyx_n_s_outminidx, __pyx_k_outminidx, sizeof(__pyx_k_outminidx), 0, 0, 1, 1},
-  {&__pyx_n_s_outnbelement, __pyx_k_outnbelement, sizeof(__pyx_k_outnbelement), 0, 0, 1, 1},
-  {&__pyx_n_s_output, __pyx_k_output, sizeof(__pyx_k_output), 0, 0, 1, 1},
-  {&__pyx_n_s_output_flags, __pyx_k_output_flags, sizeof(__pyx_k_output_flags), 0, 0, 1, 1},
-  {&__pyx_n_s_output_name, __pyx_k_output_name, sizeof(__pyx_k_output_name), 0, 0, 1, 1},
-  {&__pyx_n_s_output_names, __pyx_k_output_names, sizeof(__pyx_k_output_names), 0, 0, 1, 1},
-  {&__pyx_n_s_outputs, __pyx_k_outputs, sizeof(__pyx_k_outputs), 0, 0, 1, 1},
-  {&__pyx_n_s_outquadrature, __pyx_k_outquadrature, sizeof(__pyx_k_outquadrature), 0, 0, 1, 1},
-  {&__pyx_n_s_outreal, __pyx_k_outreal, sizeof(__pyx_k_outreal), 0, 0, 1, 1},
-  {&__pyx_n_s_outreallowerband, __pyx_k_outreallowerband, sizeof(__pyx_k_outreallowerband), 0, 0, 1, 1},
-  {&__pyx_n_s_outrealmiddleband, __pyx_k_outrealmiddleband, sizeof(__pyx_k_outrealmiddleband), 0, 0, 1, 1},
-  {&__pyx_n_s_outrealupperband, __pyx_k_outrealupperband, sizeof(__pyx_k_outrealupperband), 0, 0, 1, 1},
-  {&__pyx_n_s_outsine, __pyx_k_outsine, sizeof(__pyx_k_outsine), 0, 0, 1, 1},
-  {&__pyx_n_s_outslowd, __pyx_k_outslowd, sizeof(__pyx_k_outslowd), 0, 0, 1, 1},
-  {&__pyx_n_s_outslowk, __pyx_k_outslowk, sizeof(__pyx_k_outslowk), 0, 0, 1, 1},
-  {&__pyx_n_s_pandas, __pyx_k_pandas, sizeof(__pyx_k_pandas), 0, 0, 1, 1},
-  {&__pyx_n_s_param, __pyx_k_param, sizeof(__pyx_k_param), 0, 0, 1, 1},
-  {&__pyx_n_s_param_name, __pyx_k_param_name, sizeof(__pyx_k_param_name), 0, 0, 1, 1},
-  {&__pyx_n_s_parameters, __pyx_k_parameters, sizeof(__pyx_k_parameters), 0, 0, 1, 1},
-  {&__pyx_n_s_params, __pyx_k_params, sizeof(__pyx_k_params), 0, 0, 1, 1},
-  {&__pyx_n_s_penetration, __pyx_k_penetration, sizeof(__pyx_k_penetration), 0, 0, 1, 1},
-  {&__pyx_n_s_period, __pyx_k_period, sizeof(__pyx_k_period), 0, 0, 1, 1},
-  {&__pyx_n_s_periods, __pyx_k_periods, sizeof(__pyx_k_periods), 0, 0, 1, 1},
-  {&__pyx_n_s_periods_data, __pyx_k_periods_data, sizeof(__pyx_k_periods_data), 0, 0, 1, 1},
-  {&__pyx_n_s_pop, __pyx_k_pop, sizeof(__pyx_k_pop), 0, 0, 1, 1},
-  {&__pyx_n_s_prepare, __pyx_k_prepare, sizeof(__pyx_k_prepare), 0, 0, 1, 1},
-  {&__pyx_n_s_price, __pyx_k_price, sizeof(__pyx_k_price), 0, 0, 1, 1},
-  {&__pyx_n_s_price0, __pyx_k_price0, sizeof(__pyx_k_price0), 0, 0, 1, 1},
-  {&__pyx_n_s_price1, __pyx_k_price1, sizeof(__pyx_k_price1), 0, 0, 1, 1},
-  {&__pyx_n_s_price_series, __pyx_k_price_series, sizeof(__pyx_k_price_series), 0, 0, 1, 1},
-  {&__pyx_n_s_prices, __pyx_k_prices, sizeof(__pyx_k_prices), 0, 0, 1, 1},
-  {&__pyx_n_s_property, __pyx_k_property, sizeof(__pyx_k_property), 0, 0, 1, 1},
-  {&__pyx_n_s_qualname, __pyx_k_qualname, sizeof(__pyx_k_qualname), 0, 0, 1, 1},
-  {&__pyx_n_s_range, __pyx_k_range, sizeof(__pyx_k_range), 0, 0, 1, 1},
-  {&__pyx_n_s_rangetype, __pyx_k_rangetype, sizeof(__pyx_k_rangetype), 0, 0, 1, 1},
-  {&__pyx_n_s_real, __pyx_k_real, sizeof(__pyx_k_real), 0, 0, 1, 1},
-  {&__pyx_n_s_real0, __pyx_k_real0, sizeof(__pyx_k_real0), 0, 0, 1, 1},
-  {&__pyx_n_s_real0_data, __pyx_k_real0_data, sizeof(__pyx_k_real0_data), 0, 0, 1, 1},
-  {&__pyx_n_s_real1, __pyx_k_real1, sizeof(__pyx_k_real1), 0, 0, 1, 1},
-  {&__pyx_n_s_real1_data, __pyx_k_real1_data, sizeof(__pyx_k_real1_data), 0, 0, 1, 1},
-  {&__pyx_n_s_real_data, __pyx_k_real_data, sizeof(__pyx_k_real_data), 0, 0, 1, 1},
-  {&__pyx_n_s_replace, __pyx_k_replace, sizeof(__pyx_k_replace), 0, 0, 1, 1},
-  {&__pyx_n_s_repr, __pyx_k_repr, sizeof(__pyx_k_repr), 0, 0, 1, 1},
-  {&__pyx_n_s_results, __pyx_k_results, sizeof(__pyx_k_results), 0, 0, 1, 1},
-  {&__pyx_n_s_ret, __pyx_k_ret, sizeof(__pyx_k_ret), 0, 0, 1, 1},
-  {&__pyx_n_s_retCode, __pyx_k_retCode, sizeof(__pyx_k_retCode), 0, 0, 1, 1},
-  {&__pyx_n_s_ret_code, __pyx_k_ret_code, sizeof(__pyx_k_ret_code), 0, 0, 1, 1},
-  {&__pyx_n_s_run, __pyx_k_run, sizeof(__pyx_k_run), 0, 0, 1, 1},
-  {&__pyx_n_s_s, __pyx_k_s, sizeof(__pyx_k_s), 0, 0, 1, 1},
-  {&__pyx_kp_s_s_2, __pyx_k_s_2, sizeof(__pyx_k_s_2), 0, 0, 1, 0},
-  {&__pyx_kp_s_s_3, __pyx_k_s_3, sizeof(__pyx_k_s_3), 0, 0, 1, 0},
-  {&__pyx_kp_s_s_4, __pyx_k_s_4, sizeof(__pyx_k_s_4), 0, 0, 1, 0},
-  {&__pyx_kp_s_s_function_failed_with_error_co, __pyx_k_s_function_failed_with_error_co, sizeof(__pyx_k_s_function_failed_with_error_co), 0, 0, 1, 0},
-  {&__pyx_kp_s_s_s, __pyx_k_s_s, sizeof(__pyx_k_s_s), 0, 0, 1, 0},
-  {&__pyx_kp_s_s_s_2, __pyx_k_s_s_2, sizeof(__pyx_k_s_s_2), 0, 0, 1, 0},
-  {&__pyx_n_s_self, __pyx_k_self, sizeof(__pyx_k_self), 0, 0, 1, 1},
-  {&__pyx_n_s_series, __pyx_k_series, sizeof(__pyx_k_series), 0, 0, 1, 1},
-  {&__pyx_n_s_set_function_args, __pyx_k_set_function_args, sizeof(__pyx_k_set_function_args), 0, 0, 1, 1},
-  {&__pyx_n_s_set_input_arrays, __pyx_k_set_input_arrays, sizeof(__pyx_k_set_input_arrays), 0, 0, 1, 1},
-  {&__pyx_n_s_set_input_names, __pyx_k_set_input_names, sizeof(__pyx_k_set_input_names), 0, 0, 1, 1},
-  {&__pyx_n_s_set_parameters, __pyx_k_set_parameters, sizeof(__pyx_k_set_parameters), 0, 0, 1, 1},
-  {&__pyx_n_s_settingtype, __pyx_k_settingtype, sizeof(__pyx_k_settingtype), 0, 0, 1, 1},
-  {&__pyx_n_s_signalmatype, __pyx_k_signalmatype, sizeof(__pyx_k_signalmatype), 0, 0, 1, 1},
-  {&__pyx_n_s_signalperiod, __pyx_k_signalperiod, sizeof(__pyx_k_signalperiod), 0, 0, 1, 1},
-  {&__pyx_n_s_skip_first, __pyx_k_skip_first, sizeof(__pyx_k_skip_first), 0, 0, 1, 1},
-  {&__pyx_n_s_slowd_matype, __pyx_k_slowd_matype, sizeof(__pyx_k_slowd_matype), 0, 0, 1, 1},
-  {&__pyx_n_s_slowd_period, __pyx_k_slowd_period, sizeof(__pyx_k_slowd_period), 0, 0, 1, 1},
-  {&__pyx_n_s_slowk_matype, __pyx_k_slowk_matype, sizeof(__pyx_k_slowk_matype), 0, 0, 1, 1},
-  {&__pyx_n_s_slowk_period, __pyx_k_slowk_period, sizeof(__pyx_k_slowk_period), 0, 0, 1, 1},
-  {&__pyx_n_s_slowlimit, __pyx_k_slowlimit, sizeof(__pyx_k_slowlimit), 0, 0, 1, 1},
-  {&__pyx_n_s_slowmatype, __pyx_k_slowmatype, sizeof(__pyx_k_slowmatype), 0, 0, 1, 1},
-  {&__pyx_n_s_slowperiod, __pyx_k_slowperiod, sizeof(__pyx_k_slowperiod), 0, 0, 1, 1},
-  {&__pyx_n_s_startvalue, __pyx_k_startvalue, sizeof(__pyx_k_startvalue), 0, 0, 1, 1},
-  {&__pyx_n_s_str, __pyx_k_str, sizeof(__pyx_k_str), 0, 0, 1, 1},
-  {&__pyx_n_s_str2bytes, __pyx_k_str2bytes, sizeof(__pyx_k_str2bytes), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_ACOS, __pyx_k_stream_ACOS, sizeof(__pyx_k_stream_ACOS), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_AD, __pyx_k_stream_AD, sizeof(__pyx_k_stream_AD), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_ADD, __pyx_k_stream_ADD, sizeof(__pyx_k_stream_ADD), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_ADOSC, __pyx_k_stream_ADOSC, sizeof(__pyx_k_stream_ADOSC), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_ADX, __pyx_k_stream_ADX, sizeof(__pyx_k_stream_ADX), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_ADXR, __pyx_k_stream_ADXR, sizeof(__pyx_k_stream_ADXR), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_APO, __pyx_k_stream_APO, sizeof(__pyx_k_stream_APO), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_AROON, __pyx_k_stream_AROON, sizeof(__pyx_k_stream_AROON), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_AROONOSC, __pyx_k_stream_AROONOSC, sizeof(__pyx_k_stream_AROONOSC), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_ASIN, __pyx_k_stream_ASIN, sizeof(__pyx_k_stream_ASIN), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_ATAN, __pyx_k_stream_ATAN, sizeof(__pyx_k_stream_ATAN), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_ATR, __pyx_k_stream_ATR, sizeof(__pyx_k_stream_ATR), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_AVGPRICE, __pyx_k_stream_AVGPRICE, sizeof(__pyx_k_stream_AVGPRICE), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_BBANDS, __pyx_k_stream_BBANDS, sizeof(__pyx_k_stream_BBANDS), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_BETA, __pyx_k_stream_BETA, sizeof(__pyx_k_stream_BETA), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_BOP, __pyx_k_stream_BOP, sizeof(__pyx_k_stream_BOP), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_CCI, __pyx_k_stream_CCI, sizeof(__pyx_k_stream_CCI), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_CDL2CROWS, __pyx_k_stream_CDL2CROWS, sizeof(__pyx_k_stream_CDL2CROWS), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_CDL3BLACKCROWS, __pyx_k_stream_CDL3BLACKCROWS, sizeof(__pyx_k_stream_CDL3BLACKCROWS), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_CDL3INSIDE, __pyx_k_stream_CDL3INSIDE, sizeof(__pyx_k_stream_CDL3INSIDE), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_CDL3LINESTRIKE, __pyx_k_stream_CDL3LINESTRIKE, sizeof(__pyx_k_stream_CDL3LINESTRIKE), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_CDL3OUTSIDE, __pyx_k_stream_CDL3OUTSIDE, sizeof(__pyx_k_stream_CDL3OUTSIDE), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_CDL3STARSINSOUTH, __pyx_k_stream_CDL3STARSINSOUTH, sizeof(__pyx_k_stream_CDL3STARSINSOUTH), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_CDL3WHITESOLDIERS, __pyx_k_stream_CDL3WHITESOLDIERS, sizeof(__pyx_k_stream_CDL3WHITESOLDIERS), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_CDLABANDONEDBABY, __pyx_k_stream_CDLABANDONEDBABY, sizeof(__pyx_k_stream_CDLABANDONEDBABY), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_CDLADVANCEBLOCK, __pyx_k_stream_CDLADVANCEBLOCK, sizeof(__pyx_k_stream_CDLADVANCEBLOCK), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_CDLBELTHOLD, __pyx_k_stream_CDLBELTHOLD, sizeof(__pyx_k_stream_CDLBELTHOLD), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_CDLBREAKAWAY, __pyx_k_stream_CDLBREAKAWAY, sizeof(__pyx_k_stream_CDLBREAKAWAY), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_CDLCLOSINGMARUBOZU, __pyx_k_stream_CDLCLOSINGMARUBOZU, sizeof(__pyx_k_stream_CDLCLOSINGMARUBOZU), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_CDLCONCEALBABYSWALL, __pyx_k_stream_CDLCONCEALBABYSWALL, sizeof(__pyx_k_stream_CDLCONCEALBABYSWALL), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_CDLCOUNTERATTACK, __pyx_k_stream_CDLCOUNTERATTACK, sizeof(__pyx_k_stream_CDLCOUNTERATTACK), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_CDLDARKCLOUDCOVER, __pyx_k_stream_CDLDARKCLOUDCOVER, sizeof(__pyx_k_stream_CDLDARKCLOUDCOVER), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_CDLDOJI, __pyx_k_stream_CDLDOJI, sizeof(__pyx_k_stream_CDLDOJI), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_CDLDOJISTAR, __pyx_k_stream_CDLDOJISTAR, sizeof(__pyx_k_stream_CDLDOJISTAR), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_CDLDRAGONFLYDOJI, __pyx_k_stream_CDLDRAGONFLYDOJI, sizeof(__pyx_k_stream_CDLDRAGONFLYDOJI), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_CDLENGULFING, __pyx_k_stream_CDLENGULFING, sizeof(__pyx_k_stream_CDLENGULFING), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_CDLEVENINGDOJISTAR, __pyx_k_stream_CDLEVENINGDOJISTAR, sizeof(__pyx_k_stream_CDLEVENINGDOJISTAR), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_CDLEVENINGSTAR, __pyx_k_stream_CDLEVENINGSTAR, sizeof(__pyx_k_stream_CDLEVENINGSTAR), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_CDLGAPSIDESIDEWHITE, __pyx_k_stream_CDLGAPSIDESIDEWHITE, sizeof(__pyx_k_stream_CDLGAPSIDESIDEWHITE), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_CDLGRAVESTONEDOJI, __pyx_k_stream_CDLGRAVESTONEDOJI, sizeof(__pyx_k_stream_CDLGRAVESTONEDOJI), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_CDLHAMMER, __pyx_k_stream_CDLHAMMER, sizeof(__pyx_k_stream_CDLHAMMER), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_CDLHANGINGMAN, __pyx_k_stream_CDLHANGINGMAN, sizeof(__pyx_k_stream_CDLHANGINGMAN), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_CDLHARAMI, __pyx_k_stream_CDLHARAMI, sizeof(__pyx_k_stream_CDLHARAMI), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_CDLHARAMICROSS, __pyx_k_stream_CDLHARAMICROSS, sizeof(__pyx_k_stream_CDLHARAMICROSS), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_CDLHIGHWAVE, __pyx_k_stream_CDLHIGHWAVE, sizeof(__pyx_k_stream_CDLHIGHWAVE), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_CDLHIKKAKE, __pyx_k_stream_CDLHIKKAKE, sizeof(__pyx_k_stream_CDLHIKKAKE), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_CDLHIKKAKEMOD, __pyx_k_stream_CDLHIKKAKEMOD, sizeof(__pyx_k_stream_CDLHIKKAKEMOD), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_CDLHOMINGPIGEON, __pyx_k_stream_CDLHOMINGPIGEON, sizeof(__pyx_k_stream_CDLHOMINGPIGEON), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_CDLIDENTICAL3CROWS, __pyx_k_stream_CDLIDENTICAL3CROWS, sizeof(__pyx_k_stream_CDLIDENTICAL3CROWS), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_CDLINNECK, __pyx_k_stream_CDLINNECK, sizeof(__pyx_k_stream_CDLINNECK), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_CDLINVERTEDHAMMER, __pyx_k_stream_CDLINVERTEDHAMMER, sizeof(__pyx_k_stream_CDLINVERTEDHAMMER), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_CDLKICKING, __pyx_k_stream_CDLKICKING, sizeof(__pyx_k_stream_CDLKICKING), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_CDLKICKINGBYLENGTH, __pyx_k_stream_CDLKICKINGBYLENGTH, sizeof(__pyx_k_stream_CDLKICKINGBYLENGTH), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_CDLLADDERBOTTOM, __pyx_k_stream_CDLLADDERBOTTOM, sizeof(__pyx_k_stream_CDLLADDERBOTTOM), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_CDLLONGLEGGEDDOJI, __pyx_k_stream_CDLLONGLEGGEDDOJI, sizeof(__pyx_k_stream_CDLLONGLEGGEDDOJI), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_CDLLONGLINE, __pyx_k_stream_CDLLONGLINE, sizeof(__pyx_k_stream_CDLLONGLINE), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_CDLMARUBOZU, __pyx_k_stream_CDLMARUBOZU, sizeof(__pyx_k_stream_CDLMARUBOZU), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_CDLMATCHINGLOW, __pyx_k_stream_CDLMATCHINGLOW, sizeof(__pyx_k_stream_CDLMATCHINGLOW), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_CDLMATHOLD, __pyx_k_stream_CDLMATHOLD, sizeof(__pyx_k_stream_CDLMATHOLD), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_CDLMORNINGDOJISTAR, __pyx_k_stream_CDLMORNINGDOJISTAR, sizeof(__pyx_k_stream_CDLMORNINGDOJISTAR), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_CDLMORNINGSTAR, __pyx_k_stream_CDLMORNINGSTAR, sizeof(__pyx_k_stream_CDLMORNINGSTAR), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_CDLONNECK, __pyx_k_stream_CDLONNECK, sizeof(__pyx_k_stream_CDLONNECK), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_CDLPIERCING, __pyx_k_stream_CDLPIERCING, sizeof(__pyx_k_stream_CDLPIERCING), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_CDLRICKSHAWMAN, __pyx_k_stream_CDLRICKSHAWMAN, sizeof(__pyx_k_stream_CDLRICKSHAWMAN), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_CDLRISEFALL3METHODS, __pyx_k_stream_CDLRISEFALL3METHODS, sizeof(__pyx_k_stream_CDLRISEFALL3METHODS), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_CDLSEPARATINGLINES, __pyx_k_stream_CDLSEPARATINGLINES, sizeof(__pyx_k_stream_CDLSEPARATINGLINES), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_CDLSHOOTINGSTAR, __pyx_k_stream_CDLSHOOTINGSTAR, sizeof(__pyx_k_stream_CDLSHOOTINGSTAR), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_CDLSHORTLINE, __pyx_k_stream_CDLSHORTLINE, sizeof(__pyx_k_stream_CDLSHORTLINE), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_CDLSPINNINGTOP, __pyx_k_stream_CDLSPINNINGTOP, sizeof(__pyx_k_stream_CDLSPINNINGTOP), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_CDLSTALLEDPATTERN, __pyx_k_stream_CDLSTALLEDPATTERN, sizeof(__pyx_k_stream_CDLSTALLEDPATTERN), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_CDLSTICKSANDWICH, __pyx_k_stream_CDLSTICKSANDWICH, sizeof(__pyx_k_stream_CDLSTICKSANDWICH), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_CDLTAKURI, __pyx_k_stream_CDLTAKURI, sizeof(__pyx_k_stream_CDLTAKURI), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_CDLTASUKIGAP, __pyx_k_stream_CDLTASUKIGAP, sizeof(__pyx_k_stream_CDLTASUKIGAP), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_CDLTHRUSTING, __pyx_k_stream_CDLTHRUSTING, sizeof(__pyx_k_stream_CDLTHRUSTING), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_CDLTRISTAR, __pyx_k_stream_CDLTRISTAR, sizeof(__pyx_k_stream_CDLTRISTAR), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_CDLUNIQUE3RIVER, __pyx_k_stream_CDLUNIQUE3RIVER, sizeof(__pyx_k_stream_CDLUNIQUE3RIVER), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_CDLUPSIDEGAP2CROWS, __pyx_k_stream_CDLUPSIDEGAP2CROWS, sizeof(__pyx_k_stream_CDLUPSIDEGAP2CROWS), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_CDLXSIDEGAP3METHODS, __pyx_k_stream_CDLXSIDEGAP3METHODS, sizeof(__pyx_k_stream_CDLXSIDEGAP3METHODS), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_CEIL, __pyx_k_stream_CEIL, sizeof(__pyx_k_stream_CEIL), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_CMO, __pyx_k_stream_CMO, sizeof(__pyx_k_stream_CMO), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_CORREL, __pyx_k_stream_CORREL, sizeof(__pyx_k_stream_CORREL), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_COS, __pyx_k_stream_COS, sizeof(__pyx_k_stream_COS), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_COSH, __pyx_k_stream_COSH, sizeof(__pyx_k_stream_COSH), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_DEMA, __pyx_k_stream_DEMA, sizeof(__pyx_k_stream_DEMA), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_DIV, __pyx_k_stream_DIV, sizeof(__pyx_k_stream_DIV), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_DX, __pyx_k_stream_DX, sizeof(__pyx_k_stream_DX), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_EMA, __pyx_k_stream_EMA, sizeof(__pyx_k_stream_EMA), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_EXP, __pyx_k_stream_EXP, sizeof(__pyx_k_stream_EXP), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_FLOOR, __pyx_k_stream_FLOOR, sizeof(__pyx_k_stream_FLOOR), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_HT_DCPERIOD, __pyx_k_stream_HT_DCPERIOD, sizeof(__pyx_k_stream_HT_DCPERIOD), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_HT_DCPHASE, __pyx_k_stream_HT_DCPHASE, sizeof(__pyx_k_stream_HT_DCPHASE), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_HT_PHASOR, __pyx_k_stream_HT_PHASOR, sizeof(__pyx_k_stream_HT_PHASOR), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_HT_SINE, __pyx_k_stream_HT_SINE, sizeof(__pyx_k_stream_HT_SINE), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_HT_TRENDLINE, __pyx_k_stream_HT_TRENDLINE, sizeof(__pyx_k_stream_HT_TRENDLINE), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_HT_TRENDMODE, __pyx_k_stream_HT_TRENDMODE, sizeof(__pyx_k_stream_HT_TRENDMODE), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_KAMA, __pyx_k_stream_KAMA, sizeof(__pyx_k_stream_KAMA), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_LINEARREG, __pyx_k_stream_LINEARREG, sizeof(__pyx_k_stream_LINEARREG), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_LINEARREG_ANGLE, __pyx_k_stream_LINEARREG_ANGLE, sizeof(__pyx_k_stream_LINEARREG_ANGLE), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_LINEARREG_INTERCEPT, __pyx_k_stream_LINEARREG_INTERCEPT, sizeof(__pyx_k_stream_LINEARREG_INTERCEPT), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_LINEARREG_SLOPE, __pyx_k_stream_LINEARREG_SLOPE, sizeof(__pyx_k_stream_LINEARREG_SLOPE), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_LN, __pyx_k_stream_LN, sizeof(__pyx_k_stream_LN), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_LOG10, __pyx_k_stream_LOG10, sizeof(__pyx_k_stream_LOG10), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_MA, __pyx_k_stream_MA, sizeof(__pyx_k_stream_MA), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_MACD, __pyx_k_stream_MACD, sizeof(__pyx_k_stream_MACD), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_MACDEXT, __pyx_k_stream_MACDEXT, sizeof(__pyx_k_stream_MACDEXT), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_MACDFIX, __pyx_k_stream_MACDFIX, sizeof(__pyx_k_stream_MACDFIX), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_MAMA, __pyx_k_stream_MAMA, sizeof(__pyx_k_stream_MAMA), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_MAVP, __pyx_k_stream_MAVP, sizeof(__pyx_k_stream_MAVP), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_MAX, __pyx_k_stream_MAX, sizeof(__pyx_k_stream_MAX), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_MAXINDEX, __pyx_k_stream_MAXINDEX, sizeof(__pyx_k_stream_MAXINDEX), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_MEDPRICE, __pyx_k_stream_MEDPRICE, sizeof(__pyx_k_stream_MEDPRICE), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_MFI, __pyx_k_stream_MFI, sizeof(__pyx_k_stream_MFI), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_MIDPOINT, __pyx_k_stream_MIDPOINT, sizeof(__pyx_k_stream_MIDPOINT), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_MIDPRICE, __pyx_k_stream_MIDPRICE, sizeof(__pyx_k_stream_MIDPRICE), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_MIN, __pyx_k_stream_MIN, sizeof(__pyx_k_stream_MIN), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_MININDEX, __pyx_k_stream_MININDEX, sizeof(__pyx_k_stream_MININDEX), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_MINMAX, __pyx_k_stream_MINMAX, sizeof(__pyx_k_stream_MINMAX), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_MINMAXINDEX, __pyx_k_stream_MINMAXINDEX, sizeof(__pyx_k_stream_MINMAXINDEX), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_MINUS_DI, __pyx_k_stream_MINUS_DI, sizeof(__pyx_k_stream_MINUS_DI), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_MINUS_DM, __pyx_k_stream_MINUS_DM, sizeof(__pyx_k_stream_MINUS_DM), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_MOM, __pyx_k_stream_MOM, sizeof(__pyx_k_stream_MOM), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_MULT, __pyx_k_stream_MULT, sizeof(__pyx_k_stream_MULT), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_NATR, __pyx_k_stream_NATR, sizeof(__pyx_k_stream_NATR), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_OBV, __pyx_k_stream_OBV, sizeof(__pyx_k_stream_OBV), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_PLUS_DI, __pyx_k_stream_PLUS_DI, sizeof(__pyx_k_stream_PLUS_DI), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_PLUS_DM, __pyx_k_stream_PLUS_DM, sizeof(__pyx_k_stream_PLUS_DM), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_PPO, __pyx_k_stream_PPO, sizeof(__pyx_k_stream_PPO), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_ROC, __pyx_k_stream_ROC, sizeof(__pyx_k_stream_ROC), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_ROCP, __pyx_k_stream_ROCP, sizeof(__pyx_k_stream_ROCP), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_ROCR, __pyx_k_stream_ROCR, sizeof(__pyx_k_stream_ROCR), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_ROCR100, __pyx_k_stream_ROCR100, sizeof(__pyx_k_stream_ROCR100), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_RSI, __pyx_k_stream_RSI, sizeof(__pyx_k_stream_RSI), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_SAR, __pyx_k_stream_SAR, sizeof(__pyx_k_stream_SAR), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_SAREXT, __pyx_k_stream_SAREXT, sizeof(__pyx_k_stream_SAREXT), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_SIN, __pyx_k_stream_SIN, sizeof(__pyx_k_stream_SIN), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_SINH, __pyx_k_stream_SINH, sizeof(__pyx_k_stream_SINH), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_SMA, __pyx_k_stream_SMA, sizeof(__pyx_k_stream_SMA), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_SQRT, __pyx_k_stream_SQRT, sizeof(__pyx_k_stream_SQRT), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_STDDEV, __pyx_k_stream_STDDEV, sizeof(__pyx_k_stream_STDDEV), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_STOCH, __pyx_k_stream_STOCH, sizeof(__pyx_k_stream_STOCH), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_STOCHF, __pyx_k_stream_STOCHF, sizeof(__pyx_k_stream_STOCHF), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_STOCHRSI, __pyx_k_stream_STOCHRSI, sizeof(__pyx_k_stream_STOCHRSI), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_SUB, __pyx_k_stream_SUB, sizeof(__pyx_k_stream_SUB), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_SUM, __pyx_k_stream_SUM, sizeof(__pyx_k_stream_SUM), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_T3, __pyx_k_stream_T3, sizeof(__pyx_k_stream_T3), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_TAN, __pyx_k_stream_TAN, sizeof(__pyx_k_stream_TAN), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_TANH, __pyx_k_stream_TANH, sizeof(__pyx_k_stream_TANH), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_TEMA, __pyx_k_stream_TEMA, sizeof(__pyx_k_stream_TEMA), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_TRANGE, __pyx_k_stream_TRANGE, sizeof(__pyx_k_stream_TRANGE), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_TRIMA, __pyx_k_stream_TRIMA, sizeof(__pyx_k_stream_TRIMA), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_TRIX, __pyx_k_stream_TRIX, sizeof(__pyx_k_stream_TRIX), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_TSF, __pyx_k_stream_TSF, sizeof(__pyx_k_stream_TSF), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_TYPPRICE, __pyx_k_stream_TYPPRICE, sizeof(__pyx_k_stream_TYPPRICE), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_ULTOSC, __pyx_k_stream_ULTOSC, sizeof(__pyx_k_stream_ULTOSC), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_VAR, __pyx_k_stream_VAR, sizeof(__pyx_k_stream_VAR), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_WCLPRICE, __pyx_k_stream_WCLPRICE, sizeof(__pyx_k_stream_WCLPRICE), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_WILLR, __pyx_k_stream_WILLR, sizeof(__pyx_k_stream_WILLR), 0, 0, 1, 1},
-  {&__pyx_n_s_stream_WMA, __pyx_k_stream_WMA, sizeof(__pyx_k_stream_WMA), 0, 0, 1, 1},
-  {&__pyx_n_s_sys, __pyx_k_sys, sizeof(__pyx_k_sys), 0, 0, 1, 1},
-  {&__pyx_n_s_ta_func_unst_ids, __pyx_k_ta_func_unst_ids, sizeof(__pyx_k_ta_func_unst_ids), 0, 0, 1, 1},
-  {&__pyx_n_s_ta_getFuncInfo, __pyx_k_ta_getFuncInfo, sizeof(__pyx_k_ta_getFuncInfo), 0, 0, 1, 1},
-  {&__pyx_n_s_ta_getFuncTable, __pyx_k_ta_getFuncTable, sizeof(__pyx_k_ta_getFuncTable), 0, 0, 1, 1},
-  {&__pyx_n_s_ta_getGroupTable, __pyx_k_ta_getGroupTable, sizeof(__pyx_k_ta_getGroupTable), 0, 0, 1, 1},
-  {&__pyx_n_s_ta_getInputParameterInfo, __pyx_k_ta_getInputParameterInfo, sizeof(__pyx_k_ta_getInputParameterInfo), 0, 0, 1, 1},
-  {&__pyx_n_s_ta_getOptInputParameterInfo, __pyx_k_ta_getOptInputParameterInfo, sizeof(__pyx_k_ta_getOptInputParameterInfo), 0, 0, 1, 1},
-  {&__pyx_n_s_ta_getOutputParameterInfo, __pyx_k_ta_getOutputParameterInfo, sizeof(__pyx_k_ta_getOutputParameterInfo), 0, 0, 1, 1},
-  {&__pyx_n_s_ta_get_compatibility, __pyx_k_ta_get_compatibility, sizeof(__pyx_k_ta_get_compatibility), 0, 0, 1, 1},
-  {&__pyx_n_s_ta_get_unstable_period, __pyx_k_ta_get_unstable_period, sizeof(__pyx_k_ta_get_unstable_period), 0, 0, 1, 1},
-  {&__pyx_n_s_ta_initialize, __pyx_k_ta_initialize, sizeof(__pyx_k_ta_initialize), 0, 0, 1, 1},
-  {&__pyx_n_s_ta_restore_candle_default_setti, __pyx_k_ta_restore_candle_default_setti, sizeof(__pyx_k_ta_restore_candle_default_setti), 0, 0, 1, 1},
-  {&__pyx_n_s_ta_set_candle_settings, __pyx_k_ta_set_candle_settings, sizeof(__pyx_k_ta_set_candle_settings), 0, 0, 1, 1},
-  {&__pyx_n_s_ta_set_compatibility, __pyx_k_ta_set_compatibility, sizeof(__pyx_k_ta_set_compatibility), 0, 0, 1, 1},
-  {&__pyx_n_s_ta_set_unstable_period, __pyx_k_ta_set_unstable_period, sizeof(__pyx_k_ta_set_unstable_period), 0, 0, 1, 1},
-  {&__pyx_n_s_ta_shutdown, __pyx_k_ta_shutdown, sizeof(__pyx_k_ta_shutdown), 0, 0, 1, 1},
-  {&__pyx_n_s_ta_version, __pyx_k_ta_version, sizeof(__pyx_k_ta_version), 0, 0, 1, 1},
-  {&__pyx_n_s_table, __pyx_k_table, sizeof(__pyx_k_table), 0, 0, 1, 1},
-  {&__pyx_kp_s_talib__abstract_pxi, __pyx_k_talib__abstract_pxi, sizeof(__pyx_k_talib__abstract_pxi), 0, 0, 1, 0},
-  {&__pyx_kp_s_talib__common_pxi, __pyx_k_talib__common_pxi, sizeof(__pyx_k_talib__common_pxi), 0, 0, 1, 0},
-  {&__pyx_kp_s_talib__func_pxi, __pyx_k_talib__func_pxi, sizeof(__pyx_k_talib__func_pxi), 0, 0, 1, 0},
-  {&__pyx_kp_s_talib__stream_pxi, __pyx_k_talib__stream_pxi, sizeof(__pyx_k_talib__stream_pxi), 0, 0, 1, 0},
-  {&__pyx_n_s_talib__ta_lib, __pyx_k_talib__ta_lib, sizeof(__pyx_k_talib__ta_lib), 0, 0, 1, 1},
-  {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1},
-  {&__pyx_n_s_timeStamp, __pyx_k_timeStamp, sizeof(__pyx_k_timeStamp), 0, 0, 1, 1},
-  {&__pyx_n_s_timeperiod, __pyx_k_timeperiod, sizeof(__pyx_k_timeperiod), 0, 0, 1, 1},
-  {&__pyx_n_s_timeperiod1, __pyx_k_timeperiod1, sizeof(__pyx_k_timeperiod1), 0, 0, 1, 1},
-  {&__pyx_n_s_timeperiod2, __pyx_k_timeperiod2, sizeof(__pyx_k_timeperiod2), 0, 0, 1, 1},
-  {&__pyx_n_s_timeperiod3, __pyx_k_timeperiod3, sizeof(__pyx_k_timeperiod3), 0, 0, 1, 1},
-  {&__pyx_n_s_type, __pyx_k_type, sizeof(__pyx_k_type), 0, 0, 1, 1},
-  {&__pyx_n_s_type_2, __pyx_k_type_2, sizeof(__pyx_k_type_2), 0, 0, 1, 1},
-  {&__pyx_n_s_unicode, __pyx_k_unicode, sizeof(__pyx_k_unicode), 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_update, __pyx_k_update, sizeof(__pyx_k_update), 0, 0, 1, 1},
-  {&__pyx_n_s_update_info, __pyx_k_update_info, sizeof(__pyx_k_update_info), 0, 0, 1, 1},
-  {&__pyx_n_s_upper, __pyx_k_upper, sizeof(__pyx_k_upper), 0, 0, 1, 1},
-  {&__pyx_n_s_value, __pyx_k_value, sizeof(__pyx_k_value), 0, 0, 1, 1},
-  {&__pyx_n_s_value_range, __pyx_k_value_range, sizeof(__pyx_k_value_range), 0, 0, 1, 1},
-  {&__pyx_n_s_values, __pyx_k_values, sizeof(__pyx_k_values), 0, 0, 1, 1},
-  {&__pyx_n_s_version, __pyx_k_version, sizeof(__pyx_k_version), 0, 0, 1, 1},
-  {&__pyx_n_s_vfactor, __pyx_k_vfactor, sizeof(__pyx_k_vfactor), 0, 0, 1, 1},
-  {&__pyx_n_s_volume, __pyx_k_volume, sizeof(__pyx_k_volume), 0, 0, 1, 1},
-  {&__pyx_n_s_volume_data, __pyx_k_volume_data, sizeof(__pyx_k_volume_data), 0, 0, 1, 1},
-  {&__pyx_n_s_xrange, __pyx_k_xrange, sizeof(__pyx_k_xrange), 0, 0, 1, 1},
-  {0, 0, 0, 0, 0, 0, 0}
-};
-static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) {
-  __pyx_builtin_object = __Pyx_GetBuiltinName(__pyx_n_s_object); if (!__pyx_builtin_object) __PYX_ERR(0, 60, __pyx_L1_error)
-  __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_range) __PYX_ERR(0, 61, __pyx_L1_error)
-  __pyx_builtin_enumerate = __Pyx_GetBuiltinName(__pyx_n_s_enumerate); if (!__pyx_builtin_enumerate) __PYX_ERR(0, 82, __pyx_L1_error)
-  __pyx_builtin_ImportError = __Pyx_GetBuiltinName(__pyx_n_s_ImportError); if (!__pyx_builtin_ImportError) __PYX_ERR(1, 7, __pyx_L1_error)
-  __pyx_builtin_property = __Pyx_GetBuiltinName(__pyx_n_s_property); if (!__pyx_builtin_property) __PYX_ERR(1, 138, __pyx_L1_error)
-  #if PY_MAJOR_VERSION >= 3
-  __pyx_builtin_xrange = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_xrange) __PYX_ERR(1, 114, __pyx_L1_error)
-  #else
-  __pyx_builtin_xrange = __Pyx_GetBuiltinName(__pyx_n_s_xrange); if (!__pyx_builtin_xrange) __PYX_ERR(1, 114, __pyx_L1_error)
-  #endif
-  __pyx_builtin_IndexError = __Pyx_GetBuiltinName(__pyx_n_s_IndexError); if (!__pyx_builtin_IndexError) __PYX_ERR(1, 374, __pyx_L1_error)
-  __pyx_builtin_TypeError = __Pyx_GetBuiltinName(__pyx_n_s_TypeError); if (!__pyx_builtin_TypeError) __PYX_ERR(1, 378, __pyx_L1_error)
-  __pyx_builtin_min = __Pyx_GetBuiltinName(__pyx_n_s_min); if (!__pyx_builtin_min) __PYX_ERR(1, 515, __pyx_L1_error)
-  __pyx_builtin_max = __Pyx_GetBuiltinName(__pyx_n_s_max); if (!__pyx_builtin_max) __PYX_ERR(1, 516, __pyx_L1_error)
-  __pyx_builtin_ValueError = __Pyx_GetBuiltinName(__pyx_n_s_ValueError); if (!__pyx_builtin_ValueError) __PYX_ERR(4, 272, __pyx_L1_error)
-  __pyx_builtin_RuntimeError = __Pyx_GetBuiltinName(__pyx_n_s_RuntimeError); if (!__pyx_builtin_RuntimeError) __PYX_ERR(4, 856, __pyx_L1_error)
-  return 0;
-  __pyx_L1_error:;
-  return -1;
-}
+  __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high));
 
-static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) {
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0);
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4815, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
 
-  __pyx_tuple_ = PyTuple_Pack(1, __pyx_kp_s_input_array_type_is_not_double); if (unlikely(!__pyx_tuple_)) __PYX_ERR(2, 22, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple_);
-  __Pyx_GIVEREF(__pyx_tuple_);
-
-  __pyx_tuple__2 = PyTuple_Pack(1, __pyx_kp_s_input_array_has_wrong_dimensions); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(2, 24, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__2);
-  __Pyx_GIVEREF(__pyx_tuple__2);
-
-  __pyx_tuple__3 = PyTuple_Pack(1, __pyx_kp_s_input_array_lengths_are_differen); if (unlikely(!__pyx_tuple__3)) __PYX_ERR(2, 34, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__3);
-  __Pyx_GIVEREF(__pyx_tuple__3);
-
-  __pyx_tuple__4 = PyTuple_Pack(1, __pyx_kp_s_inputs_are_all_NaN); if (unlikely(!__pyx_tuple__4)) __PYX_ERR(2, 68, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__4);
-  __Pyx_GIVEREF(__pyx_tuple__4);
-
-  __pyx_tuple__7 = PyTuple_Pack(2, __pyx_n_s_real, __pyx_n_s_price); if (unlikely(!__pyx_tuple__7)) __PYX_ERR(1, 596, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__7);
-  __Pyx_GIVEREF(__pyx_tuple__7);
-
-  __pyx_tuple__12 = PyTuple_Pack(1, __pyx_kp_u_ndarray_is_not_C_contiguous); if (unlikely(!__pyx_tuple__12)) __PYX_ERR(4, 272, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__12);
-  __Pyx_GIVEREF(__pyx_tuple__12);
-
-  __pyx_tuple__13 = PyTuple_Pack(1, __pyx_kp_u_ndarray_is_not_Fortran_contiguou); if (unlikely(!__pyx_tuple__13)) __PYX_ERR(4, 276, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__13);
-  __Pyx_GIVEREF(__pyx_tuple__13);
-
-  __pyx_tuple__14 = PyTuple_Pack(1, __pyx_kp_u_Non_native_byte_order_not_suppor); if (unlikely(!__pyx_tuple__14)) __PYX_ERR(4, 306, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__14);
-  __Pyx_GIVEREF(__pyx_tuple__14);
-
-  __pyx_tuple__15 = PyTuple_Pack(1, __pyx_kp_u_Format_string_allocated_too_shor); if (unlikely(!__pyx_tuple__15)) __PYX_ERR(4, 856, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__15);
-  __Pyx_GIVEREF(__pyx_tuple__15);
-
-  __pyx_tuple__16 = PyTuple_Pack(1, __pyx_kp_u_Format_string_allocated_too_shor_2); if (unlikely(!__pyx_tuple__16)) __PYX_ERR(4, 880, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__16);
-  __Pyx_GIVEREF(__pyx_tuple__16);
-
-  __pyx_tuple__17 = PyTuple_Pack(1, __pyx_kp_s_numpy_core_multiarray_failed_to); if (unlikely(!__pyx_tuple__17)) __PYX_ERR(4, 1038, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__17);
-  __Pyx_GIVEREF(__pyx_tuple__17);
-
-  __pyx_tuple__18 = PyTuple_Pack(1, __pyx_kp_s_numpy_core_umath_failed_to_impor); if (unlikely(!__pyx_tuple__18)) __PYX_ERR(4, 1044, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__18);
-  __Pyx_GIVEREF(__pyx_tuple__18);
-
-  __pyx_tuple__19 = PyTuple_Pack(1, __pyx_n_s_ret_code); if (unlikely(!__pyx_tuple__19)) __PYX_ERR(0, 50, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__19);
-  __Pyx_GIVEREF(__pyx_tuple__19);
-  __pyx_codeobj__20 = (PyObject*)__Pyx_PyCode_New(0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__19, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__common_pxi, __pyx_n_s_ta_initialize, 50, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__20)) __PYX_ERR(0, 50, __pyx_L1_error)
-
-  __pyx_tuple__21 = PyTuple_Pack(1, __pyx_n_s_ret_code); if (unlikely(!__pyx_tuple__21)) __PYX_ERR(0, 55, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__21);
-  __Pyx_GIVEREF(__pyx_tuple__21);
-  __pyx_codeobj__22 = (PyObject*)__Pyx_PyCode_New(0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__21, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__common_pxi, __pyx_n_s_ta_shutdown, 55, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__22)) __PYX_ERR(0, 55, __pyx_L1_error)
-
-  __pyx_tuple__23 = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_tuple__23)) __PYX_ERR(0, 60, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__23);
-  __Pyx_GIVEREF(__pyx_tuple__23);
-
-  __pyx_tuple__24 = PyTuple_Pack(1, __pyx_int_9); if (unlikely(!__pyx_tuple__24)) __PYX_ERR(0, 61, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__24);
-  __Pyx_GIVEREF(__pyx_tuple__24);
-
-  __pyx_tuple__25 = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple__25)) __PYX_ERR(0, 63, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__25);
-  __Pyx_GIVEREF(__pyx_tuple__25);
-  __pyx_codeobj__26 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__25, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__common_pxi, __pyx_n_s_init, 63, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__26)) __PYX_ERR(0, 63, __pyx_L1_error)
-
-  __pyx_tuple__27 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_type); if (unlikely(!__pyx_tuple__27)) __PYX_ERR(0, 76, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__27);
-  __Pyx_GIVEREF(__pyx_tuple__27);
-  __pyx_codeobj__28 = (PyObject*)__Pyx_PyCode_New(2, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__27, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__common_pxi, __pyx_n_s_getitem, 76, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__28)) __PYX_ERR(0, 76, __pyx_L1_error)
-
-  __pyx_tuple__29 = PyTuple_Pack(4, __pyx_n_s_name, __pyx_n_s_period, __pyx_n_s_ret_code, __pyx_n_s_id); if (unlikely(!__pyx_tuple__29)) __PYX_ERR(0, 90, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__29);
-  __Pyx_GIVEREF(__pyx_tuple__29);
-  __pyx_codeobj__30 = (PyObject*)__Pyx_PyCode_New(2, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__29, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__common_pxi, __pyx_n_s_ta_set_unstable_period, 90, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__30)) __PYX_ERR(0, 90, __pyx_L1_error)
-
-  __pyx_tuple__31 = PyTuple_Pack(3, __pyx_n_s_name, __pyx_n_s_period, __pyx_n_s_id); if (unlikely(!__pyx_tuple__31)) __PYX_ERR(0, 96, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__31);
-  __Pyx_GIVEREF(__pyx_tuple__31);
-  __pyx_codeobj__32 = (PyObject*)__Pyx_PyCode_New(1, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__31, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__common_pxi, __pyx_n_s_ta_get_unstable_period, 96, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__32)) __PYX_ERR(0, 96, __pyx_L1_error)
-
-  __pyx_tuple__33 = PyTuple_Pack(2, __pyx_n_s_value, __pyx_n_s_ret_code); if (unlikely(!__pyx_tuple__33)) __PYX_ERR(0, 102, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__33);
-  __Pyx_GIVEREF(__pyx_tuple__33);
-  __pyx_codeobj__34 = (PyObject*)__Pyx_PyCode_New(1, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__33, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__common_pxi, __pyx_n_s_ta_set_compatibility, 102, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__34)) __PYX_ERR(0, 102, __pyx_L1_error)
-
-  __pyx_tuple__35 = PyTuple_Pack(1, __pyx_n_s_value); if (unlikely(!__pyx_tuple__35)) __PYX_ERR(0, 107, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__35);
-  __Pyx_GIVEREF(__pyx_tuple__35);
-  __pyx_codeobj__36 = (PyObject*)__Pyx_PyCode_New(0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__35, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__common_pxi, __pyx_n_s_ta_get_compatibility, 107, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__36)) __PYX_ERR(0, 107, __pyx_L1_error)
-
-  __pyx_tuple__37 = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_tuple__37)) __PYX_ERR(0, 112, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__37);
-  __Pyx_GIVEREF(__pyx_tuple__37);
-
-  __pyx_tuple__38 = PyTuple_Pack(1, __pyx_int_12); if (unlikely(!__pyx_tuple__38)) __PYX_ERR(0, 115, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__38);
-  __Pyx_GIVEREF(__pyx_tuple__38);
-
-  __pyx_tuple__39 = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_tuple__39)) __PYX_ERR(0, 119, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__39);
-  __Pyx_GIVEREF(__pyx_tuple__39);
-
-  __pyx_tuple__40 = PyTuple_Pack(1, __pyx_int_3); if (unlikely(!__pyx_tuple__40)) __PYX_ERR(0, 120, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__40);
-  __Pyx_GIVEREF(__pyx_tuple__40);
-
-  __pyx_tuple__41 = PyTuple_Pack(5, __pyx_n_s_settingtype, __pyx_n_s_rangetype, __pyx_n_s_avgperiod, __pyx_n_s_factor, __pyx_n_s_ret_code); if (unlikely(!__pyx_tuple__41)) __PYX_ERR(0, 124, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__41);
-  __Pyx_GIVEREF(__pyx_tuple__41);
-  __pyx_codeobj__42 = (PyObject*)__Pyx_PyCode_New(4, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__41, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__common_pxi, __pyx_n_s_ta_set_candle_settings, 124, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__42)) __PYX_ERR(0, 124, __pyx_L1_error)
-
-  __pyx_tuple__43 = PyTuple_Pack(2, __pyx_n_s_settingtype, __pyx_n_s_ret_code); if (unlikely(!__pyx_tuple__43)) __PYX_ERR(0, 129, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__43);
-  __Pyx_GIVEREF(__pyx_tuple__43);
-  __pyx_codeobj__44 = (PyObject*)__Pyx_PyCode_New(1, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__43, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__common_pxi, __pyx_n_s_ta_restore_candle_default_setti, 129, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__44)) __PYX_ERR(0, 129, __pyx_L1_error)
-
-  __pyx_tuple__45 = PyTuple_Pack(9, __pyx_n_s_real, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__45)) __PYX_ERR(2, 144, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__45);
-  __Pyx_GIVEREF(__pyx_tuple__45);
-  __pyx_codeobj__46 = (PyObject*)__Pyx_PyCode_New(1, 0, 9, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__45, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_ACOS, 144, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__46)) __PYX_ERR(2, 144, __pyx_L1_error)
-
-  __pyx_tuple__47 = PyTuple_Pack(12, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_volume, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__47)) __PYX_ERR(2, 173, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__47);
-  __Pyx_GIVEREF(__pyx_tuple__47);
-  __pyx_codeobj__48 = (PyObject*)__Pyx_PyCode_New(4, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__47, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_AD, 173, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__48)) __PYX_ERR(2, 173, __pyx_L1_error)
-
-  __pyx_tuple__49 = PyTuple_Pack(10, __pyx_n_s_real0, __pyx_n_s_real1, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__49)) __PYX_ERR(2, 205, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__49);
-  __Pyx_GIVEREF(__pyx_tuple__49);
-  __pyx_codeobj__50 = (PyObject*)__Pyx_PyCode_New(2, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__49, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_ADD, 205, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__50)) __PYX_ERR(2, 205, __pyx_L1_error)
-
-  __pyx_tuple__51 = PyTuple_Pack(14, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_volume, __pyx_n_s_fastperiod, __pyx_n_s_slowperiod, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__51)) __PYX_ERR(2, 236, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__51);
-  __Pyx_GIVEREF(__pyx_tuple__51);
-  __pyx_codeobj__52 = (PyObject*)__Pyx_PyCode_New(6, 0, 14, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__51, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_ADOSC, 236, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__52)) __PYX_ERR(2, 236, __pyx_L1_error)
-
-  __pyx_tuple__53 = PyTuple_Pack(12, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__53)) __PYX_ERR(2, 271, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__53);
-  __Pyx_GIVEREF(__pyx_tuple__53);
-  __pyx_codeobj__54 = (PyObject*)__Pyx_PyCode_New(4, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__53, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_ADX, 271, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__54)) __PYX_ERR(2, 271, __pyx_L1_error)
-
-  __pyx_tuple__55 = PyTuple_Pack(12, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__55)) __PYX_ERR(2, 304, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__55);
-  __Pyx_GIVEREF(__pyx_tuple__55);
-  __pyx_codeobj__56 = (PyObject*)__Pyx_PyCode_New(4, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__55, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_ADXR, 304, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__56)) __PYX_ERR(2, 304, __pyx_L1_error)
-
-  __pyx_tuple__57 = PyTuple_Pack(12, __pyx_n_s_real, __pyx_n_s_fastperiod, __pyx_n_s_slowperiod, __pyx_n_s_matype, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__57)) __PYX_ERR(2, 337, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__57);
-  __Pyx_GIVEREF(__pyx_tuple__57);
-  __pyx_codeobj__58 = (PyObject*)__Pyx_PyCode_New(4, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__57, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_APO, 337, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__58)) __PYX_ERR(2, 337, __pyx_L1_error)
-
-  __pyx_tuple__59 = PyTuple_Pack(12, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outaroondown, __pyx_n_s_outaroonup); if (unlikely(!__pyx_tuple__59)) __PYX_ERR(2, 370, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__59);
-  __Pyx_GIVEREF(__pyx_tuple__59);
-  __pyx_codeobj__60 = (PyObject*)__Pyx_PyCode_New(3, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__59, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_AROON, 370, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__60)) __PYX_ERR(2, 370, __pyx_L1_error)
-
-  __pyx_tuple__61 = PyTuple_Pack(11, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__61)) __PYX_ERR(2, 405, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__61);
-  __Pyx_GIVEREF(__pyx_tuple__61);
-  __pyx_codeobj__62 = (PyObject*)__Pyx_PyCode_New(3, 0, 11, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__61, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_AROONOSC, 405, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__62)) __PYX_ERR(2, 405, __pyx_L1_error)
-
-  __pyx_tuple__63 = PyTuple_Pack(9, __pyx_n_s_real, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__63)) __PYX_ERR(2, 437, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__63);
-  __Pyx_GIVEREF(__pyx_tuple__63);
-  __pyx_codeobj__64 = (PyObject*)__Pyx_PyCode_New(1, 0, 9, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__63, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_ASIN, 437, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__64)) __PYX_ERR(2, 437, __pyx_L1_error)
-
-  __pyx_tuple__65 = PyTuple_Pack(9, __pyx_n_s_real, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__65)) __PYX_ERR(2, 466, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__65);
-  __Pyx_GIVEREF(__pyx_tuple__65);
-  __pyx_codeobj__66 = (PyObject*)__Pyx_PyCode_New(1, 0, 9, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__65, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_ATAN, 466, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__66)) __PYX_ERR(2, 466, __pyx_L1_error)
-
-  __pyx_tuple__67 = PyTuple_Pack(12, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__67)) __PYX_ERR(2, 495, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__67);
-  __Pyx_GIVEREF(__pyx_tuple__67);
-  __pyx_codeobj__68 = (PyObject*)__Pyx_PyCode_New(4, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__67, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_ATR, 495, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__68)) __PYX_ERR(2, 495, __pyx_L1_error)
-
-  __pyx_tuple__69 = PyTuple_Pack(12, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__69)) __PYX_ERR(2, 528, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__69);
-  __Pyx_GIVEREF(__pyx_tuple__69);
-  __pyx_codeobj__70 = (PyObject*)__Pyx_PyCode_New(4, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__69, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_AVGPRICE, 528, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__70)) __PYX_ERR(2, 528, __pyx_L1_error)
-
-  __pyx_tuple__71 = PyTuple_Pack(15, __pyx_n_s_real, __pyx_n_s_timeperiod, __pyx_n_s_nbdevup, __pyx_n_s_nbdevdn, __pyx_n_s_matype, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outrealupperband, __pyx_n_s_outrealmiddleband, __pyx_n_s_outreallowerband); if (unlikely(!__pyx_tuple__71)) __PYX_ERR(2, 560, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__71);
-  __Pyx_GIVEREF(__pyx_tuple__71);
-  __pyx_codeobj__72 = (PyObject*)__Pyx_PyCode_New(5, 0, 15, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__71, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_BBANDS, 560, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__72)) __PYX_ERR(2, 560, __pyx_L1_error)
-
-  __pyx_tuple__73 = PyTuple_Pack(11, __pyx_n_s_real0, __pyx_n_s_real1, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__73)) __PYX_ERR(2, 600, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__73);
-  __Pyx_GIVEREF(__pyx_tuple__73);
-  __pyx_codeobj__74 = (PyObject*)__Pyx_PyCode_New(3, 0, 11, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__73, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_BETA, 600, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__74)) __PYX_ERR(2, 600, __pyx_L1_error)
-
-  __pyx_tuple__75 = PyTuple_Pack(12, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__75)) __PYX_ERR(2, 633, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__75);
-  __Pyx_GIVEREF(__pyx_tuple__75);
-  __pyx_codeobj__76 = (PyObject*)__Pyx_PyCode_New(4, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__75, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_BOP, 633, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__76)) __PYX_ERR(2, 633, __pyx_L1_error)
-
-  __pyx_tuple__77 = PyTuple_Pack(12, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__77)) __PYX_ERR(2, 665, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__77);
-  __Pyx_GIVEREF(__pyx_tuple__77);
-  __pyx_codeobj__78 = (PyObject*)__Pyx_PyCode_New(4, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__77, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CCI, 665, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__78)) __PYX_ERR(2, 665, __pyx_L1_error)
-
-  __pyx_tuple__79 = PyTuple_Pack(12, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__79)) __PYX_ERR(2, 698, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__79);
-  __Pyx_GIVEREF(__pyx_tuple__79);
-  __pyx_codeobj__80 = (PyObject*)__Pyx_PyCode_New(4, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__79, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDL2CROWS, 698, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__80)) __PYX_ERR(2, 698, __pyx_L1_error)
-
-  __pyx_tuple__81 = PyTuple_Pack(12, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__81)) __PYX_ERR(2, 730, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__81);
-  __Pyx_GIVEREF(__pyx_tuple__81);
-  __pyx_codeobj__82 = (PyObject*)__Pyx_PyCode_New(4, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__81, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDL3BLACKCROWS, 730, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__82)) __PYX_ERR(2, 730, __pyx_L1_error)
-
-  __pyx_tuple__83 = PyTuple_Pack(12, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__83)) __PYX_ERR(2, 762, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__83);
-  __Pyx_GIVEREF(__pyx_tuple__83);
-  __pyx_codeobj__84 = (PyObject*)__Pyx_PyCode_New(4, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__83, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDL3INSIDE, 762, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__84)) __PYX_ERR(2, 762, __pyx_L1_error)
-
-  __pyx_tuple__85 = PyTuple_Pack(12, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__85)) __PYX_ERR(2, 794, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__85);
-  __Pyx_GIVEREF(__pyx_tuple__85);
-  __pyx_codeobj__86 = (PyObject*)__Pyx_PyCode_New(4, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__85, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDL3LINESTRIKE, 794, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__86)) __PYX_ERR(2, 794, __pyx_L1_error)
-
-  __pyx_tuple__87 = PyTuple_Pack(12, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__87)) __PYX_ERR(2, 826, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__87);
-  __Pyx_GIVEREF(__pyx_tuple__87);
-  __pyx_codeobj__88 = (PyObject*)__Pyx_PyCode_New(4, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__87, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDL3OUTSIDE, 826, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__88)) __PYX_ERR(2, 826, __pyx_L1_error)
-
-  __pyx_tuple__89 = PyTuple_Pack(12, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__89)) __PYX_ERR(2, 858, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__89);
-  __Pyx_GIVEREF(__pyx_tuple__89);
-  __pyx_codeobj__90 = (PyObject*)__Pyx_PyCode_New(4, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__89, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDL3STARSINSOUTH, 858, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__90)) __PYX_ERR(2, 858, __pyx_L1_error)
-
-  __pyx_tuple__91 = PyTuple_Pack(12, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__91)) __PYX_ERR(2, 890, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__91);
-  __Pyx_GIVEREF(__pyx_tuple__91);
-  __pyx_codeobj__92 = (PyObject*)__Pyx_PyCode_New(4, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__91, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDL3WHITESOLDIERS, 890, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__92)) __PYX_ERR(2, 890, __pyx_L1_error)
-
-  __pyx_tuple__93 = PyTuple_Pack(13, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_penetration, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__93)) __PYX_ERR(2, 922, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__93);
-  __Pyx_GIVEREF(__pyx_tuple__93);
-  __pyx_codeobj__94 = (PyObject*)__Pyx_PyCode_New(5, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__93, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLABANDONEDBABY, 922, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__94)) __PYX_ERR(2, 922, __pyx_L1_error)
-
-  __pyx_tuple__95 = PyTuple_Pack(12, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__95)) __PYX_ERR(2, 956, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__95);
-  __Pyx_GIVEREF(__pyx_tuple__95);
-  __pyx_codeobj__96 = (PyObject*)__Pyx_PyCode_New(4, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__95, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLADVANCEBLOCK, 956, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__96)) __PYX_ERR(2, 956, __pyx_L1_error)
-
-  __pyx_tuple__97 = PyTuple_Pack(12, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__97)) __PYX_ERR(2, 988, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__97);
-  __Pyx_GIVEREF(__pyx_tuple__97);
-  __pyx_codeobj__98 = (PyObject*)__Pyx_PyCode_New(4, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__97, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLBELTHOLD, 988, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__98)) __PYX_ERR(2, 988, __pyx_L1_error)
-
-  __pyx_tuple__99 = PyTuple_Pack(12, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__99)) __PYX_ERR(2, 1020, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__99);
-  __Pyx_GIVEREF(__pyx_tuple__99);
-  __pyx_codeobj__100 = (PyObject*)__Pyx_PyCode_New(4, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__99, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLBREAKAWAY, 1020, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__100)) __PYX_ERR(2, 1020, __pyx_L1_error)
-
-  __pyx_tuple__101 = PyTuple_Pack(12, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__101)) __PYX_ERR(2, 1052, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__101);
-  __Pyx_GIVEREF(__pyx_tuple__101);
-  __pyx_codeobj__102 = (PyObject*)__Pyx_PyCode_New(4, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__101, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLCLOSINGMARUBOZU, 1052, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__102)) __PYX_ERR(2, 1052, __pyx_L1_error)
-
-  __pyx_tuple__103 = PyTuple_Pack(12, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__103)) __PYX_ERR(2, 1084, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__103);
-  __Pyx_GIVEREF(__pyx_tuple__103);
-  __pyx_codeobj__104 = (PyObject*)__Pyx_PyCode_New(4, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__103, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLCONCEALBABYSWALL, 1084, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__104)) __PYX_ERR(2, 1084, __pyx_L1_error)
-
-  __pyx_tuple__105 = PyTuple_Pack(12, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__105)) __PYX_ERR(2, 1116, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__105);
-  __Pyx_GIVEREF(__pyx_tuple__105);
-  __pyx_codeobj__106 = (PyObject*)__Pyx_PyCode_New(4, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__105, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLCOUNTERATTACK, 1116, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__106)) __PYX_ERR(2, 1116, __pyx_L1_error)
-
-  __pyx_tuple__107 = PyTuple_Pack(13, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_penetration, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__107)) __PYX_ERR(2, 1148, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__107);
-  __Pyx_GIVEREF(__pyx_tuple__107);
-  __pyx_codeobj__108 = (PyObject*)__Pyx_PyCode_New(5, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__107, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLDARKCLOUDCOVER, 1148, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__108)) __PYX_ERR(2, 1148, __pyx_L1_error)
-
-  __pyx_tuple__109 = PyTuple_Pack(12, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__109)) __PYX_ERR(2, 1182, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__109);
-  __Pyx_GIVEREF(__pyx_tuple__109);
-  __pyx_codeobj__110 = (PyObject*)__Pyx_PyCode_New(4, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__109, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLDOJI, 1182, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__110)) __PYX_ERR(2, 1182, __pyx_L1_error)
-
-  __pyx_tuple__111 = PyTuple_Pack(12, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__111)) __PYX_ERR(2, 1214, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__111);
-  __Pyx_GIVEREF(__pyx_tuple__111);
-  __pyx_codeobj__112 = (PyObject*)__Pyx_PyCode_New(4, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__111, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLDOJISTAR, 1214, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__112)) __PYX_ERR(2, 1214, __pyx_L1_error)
-
-  __pyx_tuple__113 = PyTuple_Pack(12, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__113)) __PYX_ERR(2, 1246, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__113);
-  __Pyx_GIVEREF(__pyx_tuple__113);
-  __pyx_codeobj__114 = (PyObject*)__Pyx_PyCode_New(4, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__113, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLDRAGONFLYDOJI, 1246, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__114)) __PYX_ERR(2, 1246, __pyx_L1_error)
-
-  __pyx_tuple__115 = PyTuple_Pack(12, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__115)) __PYX_ERR(2, 1278, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__115);
-  __Pyx_GIVEREF(__pyx_tuple__115);
-  __pyx_codeobj__116 = (PyObject*)__Pyx_PyCode_New(4, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__115, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLENGULFING, 1278, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__116)) __PYX_ERR(2, 1278, __pyx_L1_error)
-
-  __pyx_tuple__117 = PyTuple_Pack(13, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_penetration, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__117)) __PYX_ERR(2, 1310, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__117);
-  __Pyx_GIVEREF(__pyx_tuple__117);
-  __pyx_codeobj__118 = (PyObject*)__Pyx_PyCode_New(5, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__117, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLEVENINGDOJISTAR, 1310, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__118)) __PYX_ERR(2, 1310, __pyx_L1_error)
-
-  __pyx_tuple__119 = PyTuple_Pack(13, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_penetration, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__119)) __PYX_ERR(2, 1344, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__119);
-  __Pyx_GIVEREF(__pyx_tuple__119);
-  __pyx_codeobj__120 = (PyObject*)__Pyx_PyCode_New(5, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__119, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLEVENINGSTAR, 1344, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__120)) __PYX_ERR(2, 1344, __pyx_L1_error)
-
-  __pyx_tuple__121 = PyTuple_Pack(12, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__121)) __PYX_ERR(2, 1378, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__121);
-  __Pyx_GIVEREF(__pyx_tuple__121);
-  __pyx_codeobj__122 = (PyObject*)__Pyx_PyCode_New(4, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__121, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLGAPSIDESIDEWHITE, 1378, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__122)) __PYX_ERR(2, 1378, __pyx_L1_error)
-
-  __pyx_tuple__123 = PyTuple_Pack(12, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__123)) __PYX_ERR(2, 1410, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__123);
-  __Pyx_GIVEREF(__pyx_tuple__123);
-  __pyx_codeobj__124 = (PyObject*)__Pyx_PyCode_New(4, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__123, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLGRAVESTONEDOJI, 1410, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__124)) __PYX_ERR(2, 1410, __pyx_L1_error)
-
-  __pyx_tuple__125 = PyTuple_Pack(12, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__125)) __PYX_ERR(2, 1442, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__125);
-  __Pyx_GIVEREF(__pyx_tuple__125);
-  __pyx_codeobj__126 = (PyObject*)__Pyx_PyCode_New(4, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__125, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLHAMMER, 1442, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__126)) __PYX_ERR(2, 1442, __pyx_L1_error)
-
-  __pyx_tuple__127 = PyTuple_Pack(12, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__127)) __PYX_ERR(2, 1474, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__127);
-  __Pyx_GIVEREF(__pyx_tuple__127);
-  __pyx_codeobj__128 = (PyObject*)__Pyx_PyCode_New(4, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__127, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLHANGINGMAN, 1474, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__128)) __PYX_ERR(2, 1474, __pyx_L1_error)
-
-  __pyx_tuple__129 = PyTuple_Pack(12, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__129)) __PYX_ERR(2, 1506, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__129);
-  __Pyx_GIVEREF(__pyx_tuple__129);
-  __pyx_codeobj__130 = (PyObject*)__Pyx_PyCode_New(4, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__129, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLHARAMI, 1506, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__130)) __PYX_ERR(2, 1506, __pyx_L1_error)
-
-  __pyx_tuple__131 = PyTuple_Pack(12, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__131)) __PYX_ERR(2, 1538, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__131);
-  __Pyx_GIVEREF(__pyx_tuple__131);
-  __pyx_codeobj__132 = (PyObject*)__Pyx_PyCode_New(4, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__131, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLHARAMICROSS, 1538, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__132)) __PYX_ERR(2, 1538, __pyx_L1_error)
-
-  __pyx_tuple__133 = PyTuple_Pack(12, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__133)) __PYX_ERR(2, 1570, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__133);
-  __Pyx_GIVEREF(__pyx_tuple__133);
-  __pyx_codeobj__134 = (PyObject*)__Pyx_PyCode_New(4, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__133, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLHIGHWAVE, 1570, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__134)) __PYX_ERR(2, 1570, __pyx_L1_error)
-
-  __pyx_tuple__135 = PyTuple_Pack(12, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__135)) __PYX_ERR(2, 1602, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__135);
-  __Pyx_GIVEREF(__pyx_tuple__135);
-  __pyx_codeobj__136 = (PyObject*)__Pyx_PyCode_New(4, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__135, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLHIKKAKE, 1602, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__136)) __PYX_ERR(2, 1602, __pyx_L1_error)
-
-  __pyx_tuple__137 = PyTuple_Pack(12, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__137)) __PYX_ERR(2, 1634, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__137);
-  __Pyx_GIVEREF(__pyx_tuple__137);
-  __pyx_codeobj__138 = (PyObject*)__Pyx_PyCode_New(4, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__137, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLHIKKAKEMOD, 1634, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__138)) __PYX_ERR(2, 1634, __pyx_L1_error)
-
-  __pyx_tuple__139 = PyTuple_Pack(12, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__139)) __PYX_ERR(2, 1666, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__139);
-  __Pyx_GIVEREF(__pyx_tuple__139);
-  __pyx_codeobj__140 = (PyObject*)__Pyx_PyCode_New(4, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__139, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLHOMINGPIGEON, 1666, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__140)) __PYX_ERR(2, 1666, __pyx_L1_error)
-
-  __pyx_tuple__141 = PyTuple_Pack(12, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__141)) __PYX_ERR(2, 1698, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__141);
-  __Pyx_GIVEREF(__pyx_tuple__141);
-  __pyx_codeobj__142 = (PyObject*)__Pyx_PyCode_New(4, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__141, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLIDENTICAL3CROWS, 1698, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__142)) __PYX_ERR(2, 1698, __pyx_L1_error)
-
-  __pyx_tuple__143 = PyTuple_Pack(12, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__143)) __PYX_ERR(2, 1730, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__143);
-  __Pyx_GIVEREF(__pyx_tuple__143);
-  __pyx_codeobj__144 = (PyObject*)__Pyx_PyCode_New(4, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__143, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLINNECK, 1730, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__144)) __PYX_ERR(2, 1730, __pyx_L1_error)
-
-  __pyx_tuple__145 = PyTuple_Pack(12, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__145)) __PYX_ERR(2, 1762, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__145);
-  __Pyx_GIVEREF(__pyx_tuple__145);
-  __pyx_codeobj__146 = (PyObject*)__Pyx_PyCode_New(4, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__145, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLINVERTEDHAMMER, 1762, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__146)) __PYX_ERR(2, 1762, __pyx_L1_error)
-
-  __pyx_tuple__147 = PyTuple_Pack(12, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__147)) __PYX_ERR(2, 1794, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__147);
-  __Pyx_GIVEREF(__pyx_tuple__147);
-  __pyx_codeobj__148 = (PyObject*)__Pyx_PyCode_New(4, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__147, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLKICKING, 1794, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__148)) __PYX_ERR(2, 1794, __pyx_L1_error)
-
-  __pyx_tuple__149 = PyTuple_Pack(12, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__149)) __PYX_ERR(2, 1826, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__149);
-  __Pyx_GIVEREF(__pyx_tuple__149);
-  __pyx_codeobj__150 = (PyObject*)__Pyx_PyCode_New(4, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__149, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLKICKINGBYLENGTH, 1826, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__150)) __PYX_ERR(2, 1826, __pyx_L1_error)
-
-  __pyx_tuple__151 = PyTuple_Pack(12, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__151)) __PYX_ERR(2, 1858, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__151);
-  __Pyx_GIVEREF(__pyx_tuple__151);
-  __pyx_codeobj__152 = (PyObject*)__Pyx_PyCode_New(4, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__151, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLLADDERBOTTOM, 1858, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__152)) __PYX_ERR(2, 1858, __pyx_L1_error)
-
-  __pyx_tuple__153 = PyTuple_Pack(12, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__153)) __PYX_ERR(2, 1890, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__153);
-  __Pyx_GIVEREF(__pyx_tuple__153);
-  __pyx_codeobj__154 = (PyObject*)__Pyx_PyCode_New(4, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__153, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLLONGLEGGEDDOJI, 1890, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__154)) __PYX_ERR(2, 1890, __pyx_L1_error)
-
-  __pyx_tuple__155 = PyTuple_Pack(12, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__155)) __PYX_ERR(2, 1922, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__155);
-  __Pyx_GIVEREF(__pyx_tuple__155);
-  __pyx_codeobj__156 = (PyObject*)__Pyx_PyCode_New(4, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__155, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLLONGLINE, 1922, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__156)) __PYX_ERR(2, 1922, __pyx_L1_error)
-
-  __pyx_tuple__157 = PyTuple_Pack(12, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__157)) __PYX_ERR(2, 1954, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__157);
-  __Pyx_GIVEREF(__pyx_tuple__157);
-  __pyx_codeobj__158 = (PyObject*)__Pyx_PyCode_New(4, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__157, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLMARUBOZU, 1954, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__158)) __PYX_ERR(2, 1954, __pyx_L1_error)
-
-  __pyx_tuple__159 = PyTuple_Pack(12, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__159)) __PYX_ERR(2, 1986, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__159);
-  __Pyx_GIVEREF(__pyx_tuple__159);
-  __pyx_codeobj__160 = (PyObject*)__Pyx_PyCode_New(4, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__159, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLMATCHINGLOW, 1986, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__160)) __PYX_ERR(2, 1986, __pyx_L1_error)
-
-  __pyx_tuple__161 = PyTuple_Pack(13, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_penetration, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__161)) __PYX_ERR(2, 2018, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__161);
-  __Pyx_GIVEREF(__pyx_tuple__161);
-  __pyx_codeobj__162 = (PyObject*)__Pyx_PyCode_New(5, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__161, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLMATHOLD, 2018, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__162)) __PYX_ERR(2, 2018, __pyx_L1_error)
-
-  __pyx_tuple__163 = PyTuple_Pack(13, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_penetration, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__163)) __PYX_ERR(2, 2052, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__163);
-  __Pyx_GIVEREF(__pyx_tuple__163);
-  __pyx_codeobj__164 = (PyObject*)__Pyx_PyCode_New(5, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__163, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLMORNINGDOJISTAR, 2052, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__164)) __PYX_ERR(2, 2052, __pyx_L1_error)
-
-  __pyx_tuple__165 = PyTuple_Pack(13, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_penetration, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__165)) __PYX_ERR(2, 2086, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__165);
-  __Pyx_GIVEREF(__pyx_tuple__165);
-  __pyx_codeobj__166 = (PyObject*)__Pyx_PyCode_New(5, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__165, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLMORNINGSTAR, 2086, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__166)) __PYX_ERR(2, 2086, __pyx_L1_error)
-
-  __pyx_tuple__167 = PyTuple_Pack(12, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__167)) __PYX_ERR(2, 2120, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__167);
-  __Pyx_GIVEREF(__pyx_tuple__167);
-  __pyx_codeobj__168 = (PyObject*)__Pyx_PyCode_New(4, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__167, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLONNECK, 2120, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__168)) __PYX_ERR(2, 2120, __pyx_L1_error)
-
-  __pyx_tuple__169 = PyTuple_Pack(12, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__169)) __PYX_ERR(2, 2152, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__169);
-  __Pyx_GIVEREF(__pyx_tuple__169);
-  __pyx_codeobj__170 = (PyObject*)__Pyx_PyCode_New(4, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__169, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLPIERCING, 2152, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__170)) __PYX_ERR(2, 2152, __pyx_L1_error)
-
-  __pyx_tuple__171 = PyTuple_Pack(12, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__171)) __PYX_ERR(2, 2184, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__171);
-  __Pyx_GIVEREF(__pyx_tuple__171);
-  __pyx_codeobj__172 = (PyObject*)__Pyx_PyCode_New(4, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__171, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLRICKSHAWMAN, 2184, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__172)) __PYX_ERR(2, 2184, __pyx_L1_error)
-
-  __pyx_tuple__173 = PyTuple_Pack(12, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__173)) __PYX_ERR(2, 2216, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__173);
-  __Pyx_GIVEREF(__pyx_tuple__173);
-  __pyx_codeobj__174 = (PyObject*)__Pyx_PyCode_New(4, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__173, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLRISEFALL3METHODS, 2216, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__174)) __PYX_ERR(2, 2216, __pyx_L1_error)
-
-  __pyx_tuple__175 = PyTuple_Pack(12, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__175)) __PYX_ERR(2, 2248, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__175);
-  __Pyx_GIVEREF(__pyx_tuple__175);
-  __pyx_codeobj__176 = (PyObject*)__Pyx_PyCode_New(4, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__175, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLSEPARATINGLINES, 2248, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__176)) __PYX_ERR(2, 2248, __pyx_L1_error)
-
-  __pyx_tuple__177 = PyTuple_Pack(12, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__177)) __PYX_ERR(2, 2280, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__177);
-  __Pyx_GIVEREF(__pyx_tuple__177);
-  __pyx_codeobj__178 = (PyObject*)__Pyx_PyCode_New(4, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__177, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLSHOOTINGSTAR, 2280, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__178)) __PYX_ERR(2, 2280, __pyx_L1_error)
-
-  __pyx_tuple__179 = PyTuple_Pack(12, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__179)) __PYX_ERR(2, 2312, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__179);
-  __Pyx_GIVEREF(__pyx_tuple__179);
-  __pyx_codeobj__180 = (PyObject*)__Pyx_PyCode_New(4, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__179, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLSHORTLINE, 2312, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__180)) __PYX_ERR(2, 2312, __pyx_L1_error)
-
-  __pyx_tuple__181 = PyTuple_Pack(12, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__181)) __PYX_ERR(2, 2344, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__181);
-  __Pyx_GIVEREF(__pyx_tuple__181);
-  __pyx_codeobj__182 = (PyObject*)__Pyx_PyCode_New(4, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__181, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLSPINNINGTOP, 2344, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__182)) __PYX_ERR(2, 2344, __pyx_L1_error)
-
-  __pyx_tuple__183 = PyTuple_Pack(12, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__183)) __PYX_ERR(2, 2376, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__183);
-  __Pyx_GIVEREF(__pyx_tuple__183);
-  __pyx_codeobj__184 = (PyObject*)__Pyx_PyCode_New(4, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__183, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLSTALLEDPATTERN, 2376, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__184)) __PYX_ERR(2, 2376, __pyx_L1_error)
-
-  __pyx_tuple__185 = PyTuple_Pack(12, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__185)) __PYX_ERR(2, 2408, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__185);
-  __Pyx_GIVEREF(__pyx_tuple__185);
-  __pyx_codeobj__186 = (PyObject*)__Pyx_PyCode_New(4, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__185, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLSTICKSANDWICH, 2408, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__186)) __PYX_ERR(2, 2408, __pyx_L1_error)
-
-  __pyx_tuple__187 = PyTuple_Pack(12, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__187)) __PYX_ERR(2, 2440, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__187);
-  __Pyx_GIVEREF(__pyx_tuple__187);
-  __pyx_codeobj__188 = (PyObject*)__Pyx_PyCode_New(4, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__187, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLTAKURI, 2440, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__188)) __PYX_ERR(2, 2440, __pyx_L1_error)
-
-  __pyx_tuple__189 = PyTuple_Pack(12, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__189)) __PYX_ERR(2, 2472, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__189);
-  __Pyx_GIVEREF(__pyx_tuple__189);
-  __pyx_codeobj__190 = (PyObject*)__Pyx_PyCode_New(4, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__189, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLTASUKIGAP, 2472, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__190)) __PYX_ERR(2, 2472, __pyx_L1_error)
-
-  __pyx_tuple__191 = PyTuple_Pack(12, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__191)) __PYX_ERR(2, 2504, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__191);
-  __Pyx_GIVEREF(__pyx_tuple__191);
-  __pyx_codeobj__192 = (PyObject*)__Pyx_PyCode_New(4, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__191, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLTHRUSTING, 2504, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__192)) __PYX_ERR(2, 2504, __pyx_L1_error)
-
-  __pyx_tuple__193 = PyTuple_Pack(12, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__193)) __PYX_ERR(2, 2536, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__193);
-  __Pyx_GIVEREF(__pyx_tuple__193);
-  __pyx_codeobj__194 = (PyObject*)__Pyx_PyCode_New(4, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__193, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLTRISTAR, 2536, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__194)) __PYX_ERR(2, 2536, __pyx_L1_error)
-
-  __pyx_tuple__195 = PyTuple_Pack(12, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__195)) __PYX_ERR(2, 2568, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__195);
-  __Pyx_GIVEREF(__pyx_tuple__195);
-  __pyx_codeobj__196 = (PyObject*)__Pyx_PyCode_New(4, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__195, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLUNIQUE3RIVER, 2568, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__196)) __PYX_ERR(2, 2568, __pyx_L1_error)
-
-  __pyx_tuple__197 = PyTuple_Pack(12, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__197)) __PYX_ERR(2, 2600, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__197);
-  __Pyx_GIVEREF(__pyx_tuple__197);
-  __pyx_codeobj__198 = (PyObject*)__Pyx_PyCode_New(4, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__197, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLUPSIDEGAP2CROWS, 2600, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__198)) __PYX_ERR(2, 2600, __pyx_L1_error)
-
-  __pyx_tuple__199 = PyTuple_Pack(12, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__199)) __PYX_ERR(2, 2632, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__199);
-  __Pyx_GIVEREF(__pyx_tuple__199);
-  __pyx_codeobj__200 = (PyObject*)__Pyx_PyCode_New(4, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__199, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CDLXSIDEGAP3METHODS, 2632, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__200)) __PYX_ERR(2, 2632, __pyx_L1_error)
-
-  __pyx_tuple__201 = PyTuple_Pack(9, __pyx_n_s_real, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__201)) __PYX_ERR(2, 2664, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__201);
-  __Pyx_GIVEREF(__pyx_tuple__201);
-  __pyx_codeobj__202 = (PyObject*)__Pyx_PyCode_New(1, 0, 9, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__201, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CEIL, 2664, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__202)) __PYX_ERR(2, 2664, __pyx_L1_error)
-
-  __pyx_tuple__203 = PyTuple_Pack(10, __pyx_n_s_real, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__203)) __PYX_ERR(2, 2693, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__203);
-  __Pyx_GIVEREF(__pyx_tuple__203);
-  __pyx_codeobj__204 = (PyObject*)__Pyx_PyCode_New(2, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__203, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CMO, 2693, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__204)) __PYX_ERR(2, 2693, __pyx_L1_error)
-
-  __pyx_tuple__205 = PyTuple_Pack(11, __pyx_n_s_real0, __pyx_n_s_real1, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__205)) __PYX_ERR(2, 2724, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__205);
-  __Pyx_GIVEREF(__pyx_tuple__205);
-  __pyx_codeobj__206 = (PyObject*)__Pyx_PyCode_New(3, 0, 11, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__205, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_CORREL, 2724, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__206)) __PYX_ERR(2, 2724, __pyx_L1_error)
-
-  __pyx_tuple__207 = PyTuple_Pack(9, __pyx_n_s_real, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__207)) __PYX_ERR(2, 2757, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__207);
-  __Pyx_GIVEREF(__pyx_tuple__207);
-  __pyx_codeobj__208 = (PyObject*)__Pyx_PyCode_New(1, 0, 9, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__207, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_COS, 2757, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__208)) __PYX_ERR(2, 2757, __pyx_L1_error)
-
-  __pyx_tuple__209 = PyTuple_Pack(9, __pyx_n_s_real, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__209)) __PYX_ERR(2, 2786, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__209);
-  __Pyx_GIVEREF(__pyx_tuple__209);
-  __pyx_codeobj__210 = (PyObject*)__Pyx_PyCode_New(1, 0, 9, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__209, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_COSH, 2786, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__210)) __PYX_ERR(2, 2786, __pyx_L1_error)
-
-  __pyx_tuple__211 = PyTuple_Pack(10, __pyx_n_s_real, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__211)) __PYX_ERR(2, 2815, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__211);
-  __Pyx_GIVEREF(__pyx_tuple__211);
-  __pyx_codeobj__212 = (PyObject*)__Pyx_PyCode_New(2, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__211, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_DEMA, 2815, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__212)) __PYX_ERR(2, 2815, __pyx_L1_error)
-
-  __pyx_tuple__213 = PyTuple_Pack(10, __pyx_n_s_real0, __pyx_n_s_real1, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__213)) __PYX_ERR(2, 2846, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__213);
-  __Pyx_GIVEREF(__pyx_tuple__213);
-  __pyx_codeobj__214 = (PyObject*)__Pyx_PyCode_New(2, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__213, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_DIV, 2846, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__214)) __PYX_ERR(2, 2846, __pyx_L1_error)
-
-  __pyx_tuple__215 = PyTuple_Pack(12, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__215)) __PYX_ERR(2, 2877, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__215);
-  __Pyx_GIVEREF(__pyx_tuple__215);
-  __pyx_codeobj__216 = (PyObject*)__Pyx_PyCode_New(4, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__215, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_DX, 2877, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__216)) __PYX_ERR(2, 2877, __pyx_L1_error)
-
-  __pyx_tuple__217 = PyTuple_Pack(10, __pyx_n_s_real, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__217)) __PYX_ERR(2, 2910, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__217);
-  __Pyx_GIVEREF(__pyx_tuple__217);
-  __pyx_codeobj__218 = (PyObject*)__Pyx_PyCode_New(2, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__217, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_EMA, 2910, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__218)) __PYX_ERR(2, 2910, __pyx_L1_error)
-
-  __pyx_tuple__219 = PyTuple_Pack(9, __pyx_n_s_real, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__219)) __PYX_ERR(2, 2941, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__219);
-  __Pyx_GIVEREF(__pyx_tuple__219);
-  __pyx_codeobj__220 = (PyObject*)__Pyx_PyCode_New(1, 0, 9, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__219, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_EXP, 2941, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__220)) __PYX_ERR(2, 2941, __pyx_L1_error)
-
-  __pyx_tuple__221 = PyTuple_Pack(9, __pyx_n_s_real, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__221)) __PYX_ERR(2, 2970, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__221);
-  __Pyx_GIVEREF(__pyx_tuple__221);
-  __pyx_codeobj__222 = (PyObject*)__Pyx_PyCode_New(1, 0, 9, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__221, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_FLOOR, 2970, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__222)) __PYX_ERR(2, 2970, __pyx_L1_error)
-
-  __pyx_tuple__223 = PyTuple_Pack(9, __pyx_n_s_real, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__223)) __PYX_ERR(2, 2999, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__223);
-  __Pyx_GIVEREF(__pyx_tuple__223);
-  __pyx_codeobj__224 = (PyObject*)__Pyx_PyCode_New(1, 0, 9, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__223, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_HT_DCPERIOD, 2999, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__224)) __PYX_ERR(2, 2999, __pyx_L1_error)
-
-  __pyx_tuple__225 = PyTuple_Pack(9, __pyx_n_s_real, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__225)) __PYX_ERR(2, 3028, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__225);
-  __Pyx_GIVEREF(__pyx_tuple__225);
-  __pyx_codeobj__226 = (PyObject*)__Pyx_PyCode_New(1, 0, 9, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__225, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_HT_DCPHASE, 3028, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__226)) __PYX_ERR(2, 3028, __pyx_L1_error)
-
-  __pyx_tuple__227 = PyTuple_Pack(10, __pyx_n_s_real, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinphase, __pyx_n_s_outquadrature); if (unlikely(!__pyx_tuple__227)) __PYX_ERR(2, 3057, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__227);
-  __Pyx_GIVEREF(__pyx_tuple__227);
-  __pyx_codeobj__228 = (PyObject*)__Pyx_PyCode_New(1, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__227, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_HT_PHASOR, 3057, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__228)) __PYX_ERR(2, 3057, __pyx_L1_error)
-
-  __pyx_tuple__229 = PyTuple_Pack(10, __pyx_n_s_real, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outsine, __pyx_n_s_outleadsine); if (unlikely(!__pyx_tuple__229)) __PYX_ERR(2, 3089, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__229);
-  __Pyx_GIVEREF(__pyx_tuple__229);
-  __pyx_codeobj__230 = (PyObject*)__Pyx_PyCode_New(1, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__229, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_HT_SINE, 3089, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__230)) __PYX_ERR(2, 3089, __pyx_L1_error)
-
-  __pyx_tuple__231 = PyTuple_Pack(9, __pyx_n_s_real, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__231)) __PYX_ERR(2, 3121, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__231);
-  __Pyx_GIVEREF(__pyx_tuple__231);
-  __pyx_codeobj__232 = (PyObject*)__Pyx_PyCode_New(1, 0, 9, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__231, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_HT_TRENDLINE, 3121, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__232)) __PYX_ERR(2, 3121, __pyx_L1_error)
-
-  __pyx_tuple__233 = PyTuple_Pack(9, __pyx_n_s_real, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__233)) __PYX_ERR(2, 3150, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__233);
-  __Pyx_GIVEREF(__pyx_tuple__233);
-  __pyx_codeobj__234 = (PyObject*)__Pyx_PyCode_New(1, 0, 9, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__233, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_HT_TRENDMODE, 3150, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__234)) __PYX_ERR(2, 3150, __pyx_L1_error)
-
-  __pyx_tuple__235 = PyTuple_Pack(10, __pyx_n_s_real, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__235)) __PYX_ERR(2, 3179, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__235);
-  __Pyx_GIVEREF(__pyx_tuple__235);
-  __pyx_codeobj__236 = (PyObject*)__Pyx_PyCode_New(2, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__235, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_KAMA, 3179, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__236)) __PYX_ERR(2, 3179, __pyx_L1_error)
-
-  __pyx_tuple__237 = PyTuple_Pack(10, __pyx_n_s_real, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__237)) __PYX_ERR(2, 3210, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__237);
-  __Pyx_GIVEREF(__pyx_tuple__237);
-  __pyx_codeobj__238 = (PyObject*)__Pyx_PyCode_New(2, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__237, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_LINEARREG, 3210, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__238)) __PYX_ERR(2, 3210, __pyx_L1_error)
-
-  __pyx_tuple__239 = PyTuple_Pack(10, __pyx_n_s_real, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__239)) __PYX_ERR(2, 3241, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__239);
-  __Pyx_GIVEREF(__pyx_tuple__239);
-  __pyx_codeobj__240 = (PyObject*)__Pyx_PyCode_New(2, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__239, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_LINEARREG_ANGLE, 3241, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__240)) __PYX_ERR(2, 3241, __pyx_L1_error)
-
-  __pyx_tuple__241 = PyTuple_Pack(10, __pyx_n_s_real, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__241)) __PYX_ERR(2, 3272, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__241);
-  __Pyx_GIVEREF(__pyx_tuple__241);
-  __pyx_codeobj__242 = (PyObject*)__Pyx_PyCode_New(2, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__241, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_LINEARREG_INTERCEPT, 3272, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__242)) __PYX_ERR(2, 3272, __pyx_L1_error)
-
-  __pyx_tuple__243 = PyTuple_Pack(10, __pyx_n_s_real, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__243)) __PYX_ERR(2, 3303, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__243);
-  __Pyx_GIVEREF(__pyx_tuple__243);
-  __pyx_codeobj__244 = (PyObject*)__Pyx_PyCode_New(2, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__243, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_LINEARREG_SLOPE, 3303, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__244)) __PYX_ERR(2, 3303, __pyx_L1_error)
-
-  __pyx_tuple__245 = PyTuple_Pack(9, __pyx_n_s_real, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__245)) __PYX_ERR(2, 3334, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__245);
-  __Pyx_GIVEREF(__pyx_tuple__245);
-  __pyx_codeobj__246 = (PyObject*)__Pyx_PyCode_New(1, 0, 9, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__245, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_LN, 3334, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__246)) __PYX_ERR(2, 3334, __pyx_L1_error)
-
-  __pyx_tuple__247 = PyTuple_Pack(9, __pyx_n_s_real, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__247)) __PYX_ERR(2, 3363, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__247);
-  __Pyx_GIVEREF(__pyx_tuple__247);
-  __pyx_codeobj__248 = (PyObject*)__Pyx_PyCode_New(1, 0, 9, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__247, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_LOG10, 3363, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__248)) __PYX_ERR(2, 3363, __pyx_L1_error)
-
-  __pyx_tuple__249 = PyTuple_Pack(11, __pyx_n_s_real, __pyx_n_s_timeperiod, __pyx_n_s_matype, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__249)) __PYX_ERR(2, 3392, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__249);
-  __Pyx_GIVEREF(__pyx_tuple__249);
-  __pyx_codeobj__250 = (PyObject*)__Pyx_PyCode_New(3, 0, 11, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__249, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_MA, 3392, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__250)) __PYX_ERR(2, 3392, __pyx_L1_error)
-
-  __pyx_tuple__251 = PyTuple_Pack(14, __pyx_n_s_real, __pyx_n_s_fastperiod, __pyx_n_s_slowperiod, __pyx_n_s_signalperiod, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outmacd, __pyx_n_s_outmacdsignal, __pyx_n_s_outmacdhist); if (unlikely(!__pyx_tuple__251)) __PYX_ERR(2, 3424, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__251);
-  __Pyx_GIVEREF(__pyx_tuple__251);
-  __pyx_codeobj__252 = (PyObject*)__Pyx_PyCode_New(4, 0, 14, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__251, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_MACD, 3424, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__252)) __PYX_ERR(2, 3424, __pyx_L1_error)
-
-  __pyx_tuple__253 = PyTuple_Pack(17, __pyx_n_s_real, __pyx_n_s_fastperiod, __pyx_n_s_fastmatype, __pyx_n_s_slowperiod, __pyx_n_s_slowmatype, __pyx_n_s_signalperiod, __pyx_n_s_signalmatype, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outmacd, __pyx_n_s_outmacdsignal, __pyx_n_s_outmacdhist); if (unlikely(!__pyx_tuple__253)) __PYX_ERR(2, 3463, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__253);
-  __Pyx_GIVEREF(__pyx_tuple__253);
-  __pyx_codeobj__254 = (PyObject*)__Pyx_PyCode_New(7, 0, 17, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__253, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_MACDEXT, 3463, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__254)) __PYX_ERR(2, 3463, __pyx_L1_error)
-
-  __pyx_tuple__255 = PyTuple_Pack(12, __pyx_n_s_real, __pyx_n_s_signalperiod, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outmacd, __pyx_n_s_outmacdsignal, __pyx_n_s_outmacdhist); if (unlikely(!__pyx_tuple__255)) __PYX_ERR(2, 3505, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__255);
-  __Pyx_GIVEREF(__pyx_tuple__255);
-  __pyx_codeobj__256 = (PyObject*)__Pyx_PyCode_New(2, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__255, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_MACDFIX, 3505, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__256)) __PYX_ERR(2, 3505, __pyx_L1_error)
-
-  __pyx_tuple__257 = PyTuple_Pack(12, __pyx_n_s_real, __pyx_n_s_fastlimit, __pyx_n_s_slowlimit, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outmama, __pyx_n_s_outfama); if (unlikely(!__pyx_tuple__257)) __PYX_ERR(2, 3542, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__257);
-  __Pyx_GIVEREF(__pyx_tuple__257);
-  __pyx_codeobj__258 = (PyObject*)__Pyx_PyCode_New(3, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__257, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_MAMA, 3542, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__258)) __PYX_ERR(2, 3542, __pyx_L1_error)
-
-  __pyx_tuple__259 = PyTuple_Pack(13, __pyx_n_s_real, __pyx_n_s_periods, __pyx_n_s_minperiod, __pyx_n_s_maxperiod, __pyx_n_s_matype, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__259)) __PYX_ERR(2, 3577, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__259);
-  __Pyx_GIVEREF(__pyx_tuple__259);
-  __pyx_codeobj__260 = (PyObject*)__Pyx_PyCode_New(5, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__259, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_MAVP, 3577, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__260)) __PYX_ERR(2, 3577, __pyx_L1_error)
-
-  __pyx_tuple__261 = PyTuple_Pack(10, __pyx_n_s_real, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__261)) __PYX_ERR(2, 3612, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__261);
-  __Pyx_GIVEREF(__pyx_tuple__261);
-  __pyx_codeobj__262 = (PyObject*)__Pyx_PyCode_New(2, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__261, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_MAX, 3612, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__262)) __PYX_ERR(2, 3612, __pyx_L1_error)
-
-  __pyx_tuple__263 = PyTuple_Pack(10, __pyx_n_s_real, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__263)) __PYX_ERR(2, 3643, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__263);
-  __Pyx_GIVEREF(__pyx_tuple__263);
-  __pyx_codeobj__264 = (PyObject*)__Pyx_PyCode_New(2, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__263, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_MAXINDEX, 3643, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__264)) __PYX_ERR(2, 3643, __pyx_L1_error)
-
-  __pyx_tuple__265 = PyTuple_Pack(10, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__265)) __PYX_ERR(2, 3674, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__265);
-  __Pyx_GIVEREF(__pyx_tuple__265);
-  __pyx_codeobj__266 = (PyObject*)__Pyx_PyCode_New(2, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__265, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_MEDPRICE, 3674, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__266)) __PYX_ERR(2, 3674, __pyx_L1_error)
-
-  __pyx_tuple__267 = PyTuple_Pack(13, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_volume, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__267)) __PYX_ERR(2, 3704, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__267);
-  __Pyx_GIVEREF(__pyx_tuple__267);
-  __pyx_codeobj__268 = (PyObject*)__Pyx_PyCode_New(5, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__267, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_MFI, 3704, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__268)) __PYX_ERR(2, 3704, __pyx_L1_error)
-
-  __pyx_tuple__269 = PyTuple_Pack(10, __pyx_n_s_real, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__269)) __PYX_ERR(2, 3738, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__269);
-  __Pyx_GIVEREF(__pyx_tuple__269);
-  __pyx_codeobj__270 = (PyObject*)__Pyx_PyCode_New(2, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__269, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_MIDPOINT, 3738, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__270)) __PYX_ERR(2, 3738, __pyx_L1_error)
-
-  __pyx_tuple__271 = PyTuple_Pack(11, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__271)) __PYX_ERR(2, 3769, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__271);
-  __Pyx_GIVEREF(__pyx_tuple__271);
-  __pyx_codeobj__272 = (PyObject*)__Pyx_PyCode_New(3, 0, 11, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__271, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_MIDPRICE, 3769, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__272)) __PYX_ERR(2, 3769, __pyx_L1_error)
-
-  __pyx_tuple__273 = PyTuple_Pack(10, __pyx_n_s_real, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__273)) __PYX_ERR(2, 3801, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__273);
-  __Pyx_GIVEREF(__pyx_tuple__273);
-  __pyx_codeobj__274 = (PyObject*)__Pyx_PyCode_New(2, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__273, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_MIN, 3801, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__274)) __PYX_ERR(2, 3801, __pyx_L1_error)
-
-  __pyx_tuple__275 = PyTuple_Pack(10, __pyx_n_s_real, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__275)) __PYX_ERR(2, 3832, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__275);
-  __Pyx_GIVEREF(__pyx_tuple__275);
-  __pyx_codeobj__276 = (PyObject*)__Pyx_PyCode_New(2, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__275, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_MININDEX, 3832, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__276)) __PYX_ERR(2, 3832, __pyx_L1_error)
-
-  __pyx_tuple__277 = PyTuple_Pack(11, __pyx_n_s_real, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outmin, __pyx_n_s_outmax); if (unlikely(!__pyx_tuple__277)) __PYX_ERR(2, 3863, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__277);
-  __Pyx_GIVEREF(__pyx_tuple__277);
-  __pyx_codeobj__278 = (PyObject*)__Pyx_PyCode_New(2, 0, 11, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__277, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_MINMAX, 3863, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__278)) __PYX_ERR(2, 3863, __pyx_L1_error)
-
-  __pyx_tuple__279 = PyTuple_Pack(11, __pyx_n_s_real, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outminidx, __pyx_n_s_outmaxidx); if (unlikely(!__pyx_tuple__279)) __PYX_ERR(2, 3897, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__279);
-  __Pyx_GIVEREF(__pyx_tuple__279);
-  __pyx_codeobj__280 = (PyObject*)__Pyx_PyCode_New(2, 0, 11, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__279, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_MINMAXINDEX, 3897, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__280)) __PYX_ERR(2, 3897, __pyx_L1_error)
-
-  __pyx_tuple__281 = PyTuple_Pack(12, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__281)) __PYX_ERR(2, 3931, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__281);
-  __Pyx_GIVEREF(__pyx_tuple__281);
-  __pyx_codeobj__282 = (PyObject*)__Pyx_PyCode_New(4, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__281, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_MINUS_DI, 3931, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__282)) __PYX_ERR(2, 3931, __pyx_L1_error)
-
-  __pyx_tuple__283 = PyTuple_Pack(11, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__283)) __PYX_ERR(2, 3964, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__283);
-  __Pyx_GIVEREF(__pyx_tuple__283);
-  __pyx_codeobj__284 = (PyObject*)__Pyx_PyCode_New(3, 0, 11, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__283, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_MINUS_DM, 3964, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__284)) __PYX_ERR(2, 3964, __pyx_L1_error)
-
-  __pyx_tuple__285 = PyTuple_Pack(10, __pyx_n_s_real, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__285)) __PYX_ERR(2, 3996, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__285);
-  __Pyx_GIVEREF(__pyx_tuple__285);
-  __pyx_codeobj__286 = (PyObject*)__Pyx_PyCode_New(2, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__285, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_MOM, 3996, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__286)) __PYX_ERR(2, 3996, __pyx_L1_error)
-
-  __pyx_tuple__287 = PyTuple_Pack(10, __pyx_n_s_real0, __pyx_n_s_real1, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__287)) __PYX_ERR(2, 4027, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__287);
-  __Pyx_GIVEREF(__pyx_tuple__287);
-  __pyx_codeobj__288 = (PyObject*)__Pyx_PyCode_New(2, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__287, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_MULT, 4027, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__288)) __PYX_ERR(2, 4027, __pyx_L1_error)
-
-  __pyx_tuple__289 = PyTuple_Pack(12, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__289)) __PYX_ERR(2, 4058, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__289);
-  __Pyx_GIVEREF(__pyx_tuple__289);
-  __pyx_codeobj__290 = (PyObject*)__Pyx_PyCode_New(4, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__289, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_NATR, 4058, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__290)) __PYX_ERR(2, 4058, __pyx_L1_error)
-
-  __pyx_tuple__291 = PyTuple_Pack(10, __pyx_n_s_real, __pyx_n_s_volume, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__291)) __PYX_ERR(2, 4091, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__291);
-  __Pyx_GIVEREF(__pyx_tuple__291);
-  __pyx_codeobj__292 = (PyObject*)__Pyx_PyCode_New(2, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__291, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_OBV, 4091, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__292)) __PYX_ERR(2, 4091, __pyx_L1_error)
-
-  __pyx_tuple__293 = PyTuple_Pack(12, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__293)) __PYX_ERR(2, 4122, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__293);
-  __Pyx_GIVEREF(__pyx_tuple__293);
-  __pyx_codeobj__294 = (PyObject*)__Pyx_PyCode_New(4, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__293, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_PLUS_DI, 4122, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__294)) __PYX_ERR(2, 4122, __pyx_L1_error)
-
-  __pyx_tuple__295 = PyTuple_Pack(11, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__295)) __PYX_ERR(2, 4155, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__295);
-  __Pyx_GIVEREF(__pyx_tuple__295);
-  __pyx_codeobj__296 = (PyObject*)__Pyx_PyCode_New(3, 0, 11, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__295, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_PLUS_DM, 4155, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__296)) __PYX_ERR(2, 4155, __pyx_L1_error)
-
-  __pyx_tuple__297 = PyTuple_Pack(12, __pyx_n_s_real, __pyx_n_s_fastperiod, __pyx_n_s_slowperiod, __pyx_n_s_matype, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__297)) __PYX_ERR(2, 4187, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__297);
-  __Pyx_GIVEREF(__pyx_tuple__297);
-  __pyx_codeobj__298 = (PyObject*)__Pyx_PyCode_New(4, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__297, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_PPO, 4187, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__298)) __PYX_ERR(2, 4187, __pyx_L1_error)
-
-  __pyx_tuple__299 = PyTuple_Pack(10, __pyx_n_s_real, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__299)) __PYX_ERR(2, 4220, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__299);
-  __Pyx_GIVEREF(__pyx_tuple__299);
-  __pyx_codeobj__300 = (PyObject*)__Pyx_PyCode_New(2, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__299, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_ROC, 4220, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__300)) __PYX_ERR(2, 4220, __pyx_L1_error)
-
-  __pyx_tuple__301 = PyTuple_Pack(10, __pyx_n_s_real, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__301)) __PYX_ERR(2, 4251, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__301);
-  __Pyx_GIVEREF(__pyx_tuple__301);
-  __pyx_codeobj__302 = (PyObject*)__Pyx_PyCode_New(2, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__301, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_ROCP, 4251, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__302)) __PYX_ERR(2, 4251, __pyx_L1_error)
-
-  __pyx_tuple__303 = PyTuple_Pack(10, __pyx_n_s_real, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__303)) __PYX_ERR(2, 4282, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__303);
-  __Pyx_GIVEREF(__pyx_tuple__303);
-  __pyx_codeobj__304 = (PyObject*)__Pyx_PyCode_New(2, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__303, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_ROCR, 4282, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__304)) __PYX_ERR(2, 4282, __pyx_L1_error)
-
-  __pyx_tuple__305 = PyTuple_Pack(10, __pyx_n_s_real, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__305)) __PYX_ERR(2, 4313, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__305);
-  __Pyx_GIVEREF(__pyx_tuple__305);
-  __pyx_codeobj__306 = (PyObject*)__Pyx_PyCode_New(2, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__305, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_ROCR100, 4313, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__306)) __PYX_ERR(2, 4313, __pyx_L1_error)
-
-  __pyx_tuple__307 = PyTuple_Pack(10, __pyx_n_s_real, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__307)) __PYX_ERR(2, 4344, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__307);
-  __Pyx_GIVEREF(__pyx_tuple__307);
-  __pyx_codeobj__308 = (PyObject*)__Pyx_PyCode_New(2, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__307, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_RSI, 4344, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__308)) __PYX_ERR(2, 4344, __pyx_L1_error)
-
-  __pyx_tuple__309 = PyTuple_Pack(12, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_acceleration, __pyx_n_s_maximum, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__309)) __PYX_ERR(2, 4375, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__309);
-  __Pyx_GIVEREF(__pyx_tuple__309);
-  __pyx_codeobj__310 = (PyObject*)__Pyx_PyCode_New(4, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__309, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_SAR, 4375, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__310)) __PYX_ERR(2, 4375, __pyx_L1_error)
-
-  __pyx_tuple__311 = PyTuple_Pack(18, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_startvalue, __pyx_n_s_offsetonreverse, __pyx_n_s_accelerationinitlong, __pyx_n_s_accelerationlong, __pyx_n_s_accelerationmaxlong, __pyx_n_s_accelerationinitshort, __pyx_n_s_accelerationshort, __pyx_n_s_accelerationmaxshort, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__311)) __PYX_ERR(2, 4408, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__311);
-  __Pyx_GIVEREF(__pyx_tuple__311);
-  __pyx_codeobj__312 = (PyObject*)__Pyx_PyCode_New(10, 0, 18, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__311, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_SAREXT, 4408, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__312)) __PYX_ERR(2, 4408, __pyx_L1_error)
-
-  __pyx_tuple__313 = PyTuple_Pack(9, __pyx_n_s_real, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__313)) __PYX_ERR(2, 4447, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__313);
-  __Pyx_GIVEREF(__pyx_tuple__313);
-  __pyx_codeobj__314 = (PyObject*)__Pyx_PyCode_New(1, 0, 9, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__313, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_SIN, 4447, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__314)) __PYX_ERR(2, 4447, __pyx_L1_error)
-
-  __pyx_tuple__315 = PyTuple_Pack(9, __pyx_n_s_real, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__315)) __PYX_ERR(2, 4476, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__315);
-  __Pyx_GIVEREF(__pyx_tuple__315);
-  __pyx_codeobj__316 = (PyObject*)__Pyx_PyCode_New(1, 0, 9, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__315, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_SINH, 4476, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__316)) __PYX_ERR(2, 4476, __pyx_L1_error)
-
-  __pyx_tuple__317 = PyTuple_Pack(10, __pyx_n_s_real, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__317)) __PYX_ERR(2, 4505, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__317);
-  __Pyx_GIVEREF(__pyx_tuple__317);
-  __pyx_codeobj__318 = (PyObject*)__Pyx_PyCode_New(2, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__317, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_SMA, 4505, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__318)) __PYX_ERR(2, 4505, __pyx_L1_error)
-
-  __pyx_tuple__319 = PyTuple_Pack(9, __pyx_n_s_real, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__319)) __PYX_ERR(2, 4536, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__319);
-  __Pyx_GIVEREF(__pyx_tuple__319);
-  __pyx_codeobj__320 = (PyObject*)__Pyx_PyCode_New(1, 0, 9, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__319, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_SQRT, 4536, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__320)) __PYX_ERR(2, 4536, __pyx_L1_error)
-
-  __pyx_tuple__321 = PyTuple_Pack(11, __pyx_n_s_real, __pyx_n_s_timeperiod, __pyx_n_s_nbdev, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__321)) __PYX_ERR(2, 4565, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__321);
-  __Pyx_GIVEREF(__pyx_tuple__321);
-  __pyx_codeobj__322 = (PyObject*)__Pyx_PyCode_New(3, 0, 11, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__321, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_STDDEV, 4565, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__322)) __PYX_ERR(2, 4565, __pyx_L1_error)
-
-  __pyx_tuple__323 = PyTuple_Pack(17, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_fastk_period, __pyx_n_s_slowk_period, __pyx_n_s_slowk_matype, __pyx_n_s_slowd_period, __pyx_n_s_slowd_matype, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outslowk, __pyx_n_s_outslowd); if (unlikely(!__pyx_tuple__323)) __PYX_ERR(2, 4597, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__323);
-  __Pyx_GIVEREF(__pyx_tuple__323);
-  __pyx_codeobj__324 = (PyObject*)__Pyx_PyCode_New(8, 0, 17, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__323, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_STOCH, 4597, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__324)) __PYX_ERR(2, 4597, __pyx_L1_error)
-
-  __pyx_tuple__325 = PyTuple_Pack(15, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_fastk_period, __pyx_n_s_fastd_period, __pyx_n_s_fastd_matype, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outfastk, __pyx_n_s_outfastd); if (unlikely(!__pyx_tuple__325)) __PYX_ERR(2, 4637, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__325);
-  __Pyx_GIVEREF(__pyx_tuple__325);
-  __pyx_codeobj__326 = (PyObject*)__Pyx_PyCode_New(6, 0, 15, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__325, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_STOCHF, 4637, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__326)) __PYX_ERR(2, 4637, __pyx_L1_error)
-
-  __pyx_tuple__327 = PyTuple_Pack(14, __pyx_n_s_real, __pyx_n_s_timeperiod, __pyx_n_s_fastk_period, __pyx_n_s_fastd_period, __pyx_n_s_fastd_matype, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outfastk, __pyx_n_s_outfastd); if (unlikely(!__pyx_tuple__327)) __PYX_ERR(2, 4675, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__327);
-  __Pyx_GIVEREF(__pyx_tuple__327);
-  __pyx_codeobj__328 = (PyObject*)__Pyx_PyCode_New(5, 0, 14, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__327, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_STOCHRSI, 4675, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__328)) __PYX_ERR(2, 4675, __pyx_L1_error)
-
-  __pyx_tuple__329 = PyTuple_Pack(10, __pyx_n_s_real0, __pyx_n_s_real1, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__329)) __PYX_ERR(2, 4712, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__329);
-  __Pyx_GIVEREF(__pyx_tuple__329);
-  __pyx_codeobj__330 = (PyObject*)__Pyx_PyCode_New(2, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__329, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_SUB, 4712, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__330)) __PYX_ERR(2, 4712, __pyx_L1_error)
-
-  __pyx_tuple__331 = PyTuple_Pack(10, __pyx_n_s_real, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__331)) __PYX_ERR(2, 4743, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__331);
-  __Pyx_GIVEREF(__pyx_tuple__331);
-  __pyx_codeobj__332 = (PyObject*)__Pyx_PyCode_New(2, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__331, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_SUM, 4743, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__332)) __PYX_ERR(2, 4743, __pyx_L1_error)
-
-  __pyx_tuple__333 = PyTuple_Pack(11, __pyx_n_s_real, __pyx_n_s_timeperiod, __pyx_n_s_vfactor, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__333)) __PYX_ERR(2, 4774, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__333);
-  __Pyx_GIVEREF(__pyx_tuple__333);
-  __pyx_codeobj__334 = (PyObject*)__Pyx_PyCode_New(3, 0, 11, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__333, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_T3, 4774, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__334)) __PYX_ERR(2, 4774, __pyx_L1_error)
-
-  __pyx_tuple__335 = PyTuple_Pack(9, __pyx_n_s_real, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__335)) __PYX_ERR(2, 4806, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__335);
-  __Pyx_GIVEREF(__pyx_tuple__335);
-  __pyx_codeobj__336 = (PyObject*)__Pyx_PyCode_New(1, 0, 9, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__335, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_TAN, 4806, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__336)) __PYX_ERR(2, 4806, __pyx_L1_error)
-
-  __pyx_tuple__337 = PyTuple_Pack(9, __pyx_n_s_real, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__337)) __PYX_ERR(2, 4835, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__337);
-  __Pyx_GIVEREF(__pyx_tuple__337);
-  __pyx_codeobj__338 = (PyObject*)__Pyx_PyCode_New(1, 0, 9, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__337, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_TANH, 4835, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__338)) __PYX_ERR(2, 4835, __pyx_L1_error)
-
-  __pyx_tuple__339 = PyTuple_Pack(10, __pyx_n_s_real, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__339)) __PYX_ERR(2, 4864, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__339);
-  __Pyx_GIVEREF(__pyx_tuple__339);
-  __pyx_codeobj__340 = (PyObject*)__Pyx_PyCode_New(2, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__339, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_TEMA, 4864, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__340)) __PYX_ERR(2, 4864, __pyx_L1_error)
-
-  __pyx_tuple__341 = PyTuple_Pack(11, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__341)) __PYX_ERR(2, 4895, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__341);
-  __Pyx_GIVEREF(__pyx_tuple__341);
-  __pyx_codeobj__342 = (PyObject*)__Pyx_PyCode_New(3, 0, 11, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__341, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_TRANGE, 4895, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__342)) __PYX_ERR(2, 4895, __pyx_L1_error)
-
-  __pyx_tuple__343 = PyTuple_Pack(10, __pyx_n_s_real, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__343)) __PYX_ERR(2, 4926, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__343);
-  __Pyx_GIVEREF(__pyx_tuple__343);
-  __pyx_codeobj__344 = (PyObject*)__Pyx_PyCode_New(2, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__343, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_TRIMA, 4926, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__344)) __PYX_ERR(2, 4926, __pyx_L1_error)
-
-  __pyx_tuple__345 = PyTuple_Pack(10, __pyx_n_s_real, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__345)) __PYX_ERR(2, 4957, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__345);
-  __Pyx_GIVEREF(__pyx_tuple__345);
-  __pyx_codeobj__346 = (PyObject*)__Pyx_PyCode_New(2, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__345, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_TRIX, 4957, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__346)) __PYX_ERR(2, 4957, __pyx_L1_error)
-
-  __pyx_tuple__347 = PyTuple_Pack(10, __pyx_n_s_real, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__347)) __PYX_ERR(2, 4988, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__347);
-  __Pyx_GIVEREF(__pyx_tuple__347);
-  __pyx_codeobj__348 = (PyObject*)__Pyx_PyCode_New(2, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__347, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_TSF, 4988, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__348)) __PYX_ERR(2, 4988, __pyx_L1_error)
-
-  __pyx_tuple__349 = PyTuple_Pack(11, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__349)) __PYX_ERR(2, 5019, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__349);
-  __Pyx_GIVEREF(__pyx_tuple__349);
-  __pyx_codeobj__350 = (PyObject*)__Pyx_PyCode_New(3, 0, 11, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__349, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_TYPPRICE, 5019, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__350)) __PYX_ERR(2, 5019, __pyx_L1_error)
-
-  __pyx_tuple__351 = PyTuple_Pack(14, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_timeperiod1, __pyx_n_s_timeperiod2, __pyx_n_s_timeperiod3, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__351)) __PYX_ERR(2, 5050, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__351);
-  __Pyx_GIVEREF(__pyx_tuple__351);
-  __pyx_codeobj__352 = (PyObject*)__Pyx_PyCode_New(6, 0, 14, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__351, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_ULTOSC, 5050, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__352)) __PYX_ERR(2, 5050, __pyx_L1_error)
-
-  __pyx_tuple__353 = PyTuple_Pack(11, __pyx_n_s_real, __pyx_n_s_timeperiod, __pyx_n_s_nbdev, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__353)) __PYX_ERR(2, 5085, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__353);
-  __Pyx_GIVEREF(__pyx_tuple__353);
-  __pyx_codeobj__354 = (PyObject*)__Pyx_PyCode_New(3, 0, 11, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__353, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_VAR, 5085, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__354)) __PYX_ERR(2, 5085, __pyx_L1_error)
-
-  __pyx_tuple__355 = PyTuple_Pack(11, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__355)) __PYX_ERR(2, 5117, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__355);
-  __Pyx_GIVEREF(__pyx_tuple__355);
-  __pyx_codeobj__356 = (PyObject*)__Pyx_PyCode_New(3, 0, 11, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__355, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_WCLPRICE, 5117, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__356)) __PYX_ERR(2, 5117, __pyx_L1_error)
-
-  __pyx_tuple__357 = PyTuple_Pack(12, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__357)) __PYX_ERR(2, 5148, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__357);
-  __Pyx_GIVEREF(__pyx_tuple__357);
-  __pyx_codeobj__358 = (PyObject*)__Pyx_PyCode_New(4, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__357, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_WILLR, 5148, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__358)) __PYX_ERR(2, 5148, __pyx_L1_error)
-
-  __pyx_tuple__359 = PyTuple_Pack(10, __pyx_n_s_real, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_begidx, __pyx_n_s_endidx, __pyx_n_s_lookback, __pyx_n_s_retCode, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__359)) __PYX_ERR(2, 5181, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__359);
-  __Pyx_GIVEREF(__pyx_tuple__359);
-  __pyx_codeobj__360 = (PyObject*)__Pyx_PyCode_New(2, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__359, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__func_pxi, __pyx_n_s_WMA, 5181, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__360)) __PYX_ERR(2, 5181, __pyx_L1_error)
-
-  __pyx_tuple__361 = PyTuple_Pack(1, __pyx_n_s_s); if (unlikely(!__pyx_tuple__361)) __PYX_ERR(1, 47, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__361);
-  __Pyx_GIVEREF(__pyx_tuple__361);
-  __pyx_codeobj__362 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__361, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__abstract_pxi, __pyx_n_s_str2bytes, 47, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__362)) __PYX_ERR(1, 47, __pyx_L1_error)
-
-  __pyx_tuple__363 = PyTuple_Pack(1, __pyx_n_s_b); if (unlikely(!__pyx_tuple__363)) __PYX_ERR(1, 50, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__363);
-  __Pyx_GIVEREF(__pyx_tuple__363);
-  __pyx_codeobj__364 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__363, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__abstract_pxi, __pyx_n_s_bytes2str, 50, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__364)) __PYX_ERR(1, 50, __pyx_L1_error)
-
-  __pyx_tuple__365 = PyTuple_Pack(1, __pyx_n_s_s); if (unlikely(!__pyx_tuple__365)) __PYX_ERR(1, 55, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__365);
-  __Pyx_GIVEREF(__pyx_tuple__365);
-  __pyx_codeobj__366 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__365, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__abstract_pxi, __pyx_n_s_str2bytes, 55, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__366)) __PYX_ERR(1, 55, __pyx_L1_error)
-
-  __pyx_tuple__367 = PyTuple_Pack(1, __pyx_n_s_b); if (unlikely(!__pyx_tuple__367)) __PYX_ERR(1, 58, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__367);
-  __Pyx_GIVEREF(__pyx_tuple__367);
-  __pyx_codeobj__368 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__367, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__abstract_pxi, __pyx_n_s_bytes2str, 58, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__368)) __PYX_ERR(1, 58, __pyx_L1_error)
-
-  __pyx_tuple__369 = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_tuple__369)) __PYX_ERR(1, 61, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__369);
-  __Pyx_GIVEREF(__pyx_tuple__369);
-
-  __pyx_tuple__370 = PyTuple_Pack(5, __pyx_n_s_self, __pyx_n_s_function_name, __pyx_n_s_func_object, __pyx_n_s_args, __pyx_n_s_kwargs); if (unlikely(!__pyx_tuple__370)) __PYX_ERR(1, 90, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__370);
-  __Pyx_GIVEREF(__pyx_tuple__370);
-  __pyx_codeobj__371 = (PyObject*)__Pyx_PyCode_New(3, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS|CO_VARARGS|CO_VARKEYWORDS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__370, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__abstract_pxi, __pyx_n_s_init, 90, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__371)) __PYX_ERR(1, 90, __pyx_L1_error)
-
-  __pyx_tuple__372 = PyTuple_Pack(6, __pyx_n_s_self, __pyx_n_s_i, __pyx_n_s_info, __pyx_n_s_input_name, __pyx_n_s_param_name, __pyx_n_s_output_name); if (unlikely(!__pyx_tuple__372)) __PYX_ERR(1, 109, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__372);
-  __Pyx_GIVEREF(__pyx_tuple__372);
-  __pyx_codeobj__373 = (PyObject*)__Pyx_PyCode_New(1, 0, 6, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__372, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__abstract_pxi, __pyx_n_s_initialize_function_info, 109, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__373)) __PYX_ERR(1, 109, __pyx_L1_error)
-
-  __pyx_tuple__374 = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple__374)) __PYX_ERR(1, 139, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__374);
-  __Pyx_GIVEREF(__pyx_tuple__374);
-  __pyx_codeobj__375 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__374, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__abstract_pxi, __pyx_n_s_info, 139, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__375)) __PYX_ERR(1, 139, __pyx_L1_error)
-
-  __pyx_tuple__376 = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple__376)) __PYX_ERR(1, 146, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__376);
-  __Pyx_GIVEREF(__pyx_tuple__376);
-  __pyx_codeobj__377 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__376, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__abstract_pxi, __pyx_n_s_function_flags, 146, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__377)) __PYX_ERR(1, 146, __pyx_L1_error)
-
-  __pyx_tuple__378 = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple__378)) __PYX_ERR(1, 153, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__378);
-  __Pyx_GIVEREF(__pyx_tuple__378);
-  __pyx_codeobj__379 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__378, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__abstract_pxi, __pyx_n_s_output_flags, 153, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__379)) __PYX_ERR(1, 153, __pyx_L1_error)
-
-  __pyx_tuple__380 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_ret, __pyx_n_s_input_name); if (unlikely(!__pyx_tuple__380)) __PYX_ERR(1, 159, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__380);
-  __Pyx_GIVEREF(__pyx_tuple__380);
-  __pyx_codeobj__381 = (PyObject*)__Pyx_PyCode_New(1, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__380, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__abstract_pxi, __pyx_n_s_get_input_names, 159, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__381)) __PYX_ERR(1, 159, __pyx_L1_error)
-
-  __pyx_tuple__382 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_input_names, __pyx_n_s_input_name, __pyx_n_s_price_series); if (unlikely(!__pyx_tuple__382)) __PYX_ERR(1, 169, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__382);
-  __Pyx_GIVEREF(__pyx_tuple__382);
-  __pyx_codeobj__383 = (PyObject*)__Pyx_PyCode_New(2, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__382, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__abstract_pxi, __pyx_n_s_set_input_names, 169, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__383)) __PYX_ERR(1, 169, __pyx_L1_error)
-
-  __pyx_tuple__384 = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple__384)) __PYX_ERR(1, 180, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__384);
-  __Pyx_GIVEREF(__pyx_tuple__384);
-  __pyx_codeobj__385 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__384, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__abstract_pxi, __pyx_n_s_get_input_arrays, 180, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__385)) __PYX_ERR(1, 180, __pyx_L1_error)
-
-  __pyx_tuple__386 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_input_arrays, __pyx_n_s_missing_keys, __pyx_n_s_key); if (unlikely(!__pyx_tuple__386)) __PYX_ERR(1, 186, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__386);
-  __Pyx_GIVEREF(__pyx_tuple__386);
-  __pyx_codeobj__387 = (PyObject*)__Pyx_PyCode_New(2, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__386, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__abstract_pxi, __pyx_n_s_set_input_arrays, 186, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__387)) __PYX_ERR(1, 186, __pyx_L1_error)
-
-  __pyx_tuple__388 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_ret, __pyx_n_s_opt_input); if (unlikely(!__pyx_tuple__388)) __PYX_ERR(1, 229, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__388);
-  __Pyx_GIVEREF(__pyx_tuple__388);
-  __pyx_codeobj__389 = (PyObject*)__Pyx_PyCode_New(1, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__388, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__abstract_pxi, __pyx_n_s_get_parameters, 229, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__389)) __PYX_ERR(1, 229, __pyx_L1_error)
-
-  __pyx_tuple__390 = PyTuple_Pack(5, __pyx_n_s_self, __pyx_n_s_parameters, __pyx_n_s_kwargs, __pyx_n_s_param, __pyx_n_s_value); if (unlikely(!__pyx_tuple__390)) __PYX_ERR(1, 238, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__390);
-  __Pyx_GIVEREF(__pyx_tuple__390);
-  __pyx_codeobj__391 = (PyObject*)__Pyx_PyCode_New(2, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS|CO_VARKEYWORDS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__390, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__abstract_pxi, __pyx_n_s_set_parameters, 238, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__391)) __PYX_ERR(1, 238, __pyx_L1_error)
-  __pyx_tuple__392 = PyTuple_Pack(1, ((PyObject *)Py_None)); if (unlikely(!__pyx_tuple__392)) __PYX_ERR(1, 238, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__392);
-  __Pyx_GIVEREF(__pyx_tuple__392);
-
-  __pyx_tuple__393 = PyTuple_Pack(9, __pyx_n_s_self, __pyx_n_s_args, __pyx_n_s_kwargs, __pyx_n_s_update_info, __pyx_n_s_key, __pyx_n_s_value, __pyx_n_s_skip_first, __pyx_n_s_i, __pyx_n_s_param_name); if (unlikely(!__pyx_tuple__393)) __PYX_ERR(1, 252, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__393);
-  __Pyx_GIVEREF(__pyx_tuple__393);
-  __pyx_codeobj__394 = (PyObject*)__Pyx_PyCode_New(1, 0, 9, 0, CO_OPTIMIZED|CO_NEWLOCALS|CO_VARARGS|CO_VARKEYWORDS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__393, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__abstract_pxi, __pyx_n_s_set_function_args, 252, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__394)) __PYX_ERR(1, 252, __pyx_L1_error)
-
-  __pyx_tuple__395 = PyTuple_Pack(7, __pyx_n_s_self, __pyx_n_s_holder, __pyx_n_s_i, __pyx_n_s_opt_input, __pyx_n_s_value, __pyx_n_s_type, __pyx_n_s_lookback); if (unlikely(!__pyx_tuple__395)) __PYX_ERR(1, 287, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__395);
-  __Pyx_GIVEREF(__pyx_tuple__395);
-  __pyx_codeobj__396 = (PyObject*)__Pyx_PyCode_New(1, 0, 7, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__395, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__abstract_pxi, __pyx_n_s_lookback, 287, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__396)) __PYX_ERR(1, 287, __pyx_L1_error)
-
-  __pyx_tuple__397 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_ret); if (unlikely(!__pyx_tuple__397)) __PYX_ERR(1, 307, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__397);
-  __Pyx_GIVEREF(__pyx_tuple__397);
-  __pyx_codeobj__398 = (PyObject*)__Pyx_PyCode_New(1, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__397, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__abstract_pxi, __pyx_n_s_output_names, 307, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__398)) __PYX_ERR(1, 307, __pyx_L1_error)
-
-  __pyx_tuple__399 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_ret, __pyx_n_s_index); if (unlikely(!__pyx_tuple__399)) __PYX_ERR(1, 317, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__399);
-  __Pyx_GIVEREF(__pyx_tuple__399);
-  __pyx_codeobj__400 = (PyObject*)__Pyx_PyCode_New(1, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__399, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__abstract_pxi, __pyx_n_s_outputs, 317, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__400)) __PYX_ERR(1, 317, __pyx_L1_error)
-
-  __pyx_tuple__401 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_input_arrays); if (unlikely(!__pyx_tuple__401)) __PYX_ERR(1, 340, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__401);
-  __Pyx_GIVEREF(__pyx_tuple__401);
-  __pyx_codeobj__402 = (PyObject*)__Pyx_PyCode_New(2, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__401, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__abstract_pxi, __pyx_n_s_run, 340, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__402)) __PYX_ERR(1, 340, __pyx_L1_error)
-  __pyx_tuple__403 = PyTuple_Pack(1, ((PyObject *)Py_None)); if (unlikely(!__pyx_tuple__403)) __PYX_ERR(1, 340, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__403);
-  __Pyx_GIVEREF(__pyx_tuple__403);
-
-  __pyx_tuple__404 = PyTuple_Pack(11, __pyx_n_s_self, __pyx_n_s_args, __pyx_n_s_kwargs, __pyx_n_s_opt_input_values, __pyx_n_s_input_arrays, __pyx_n_s_input_price_series_names, __pyx_n_s_i, __pyx_n_s_arg, __pyx_n_s_msg, __pyx_n_s_param_name, __pyx_n_s_value); if (unlikely(!__pyx_tuple__404)) __PYX_ERR(1, 352, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__404);
-  __Pyx_GIVEREF(__pyx_tuple__404);
-  __pyx_codeobj__405 = (PyObject*)__Pyx_PyCode_New(1, 0, 11, 0, CO_OPTIMIZED|CO_NEWLOCALS|CO_VARARGS|CO_VARKEYWORDS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__404, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__abstract_pxi, __pyx_n_s_call, 352, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__405)) __PYX_ERR(1, 352, __pyx_L1_error)
-
-  __pyx_tuple__406 = PyTuple_Pack(5, __pyx_n_s_self, __pyx_n_s_input_price_series_names, __pyx_n_s_input_name, __pyx_n_s_price_series, __pyx_n_s_name); if (unlikely(!__pyx_tuple__406)) __PYX_ERR(1, 400, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__406);
-  __Pyx_GIVEREF(__pyx_tuple__406);
-  __pyx_codeobj__407 = (PyObject*)__Pyx_PyCode_New(1, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__406, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__abstract_pxi, __pyx_n_s_input_price_series_names_2, 400, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__407)) __PYX_ERR(1, 400, __pyx_L1_error)
-
-  __pyx_tuple__408 = PyTuple_Pack(11, __pyx_n_s_self, __pyx_n_s_input_price_series_names, __pyx_n_s_args, __pyx_n_s_price_series, __pyx_n_s_series, __pyx_n_s_opt_input, __pyx_n_s_value, __pyx_n_s_results, __pyx_n_s_keys, __pyx_n_s_i, __pyx_n_s_output); if (unlikely(!__pyx_tuple__408)) __PYX_ERR(1, 411, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__408);
-  __Pyx_GIVEREF(__pyx_tuple__408);
-  __pyx_codeobj__409 = (PyObject*)__Pyx_PyCode_New(1, 0, 11, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__408, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__abstract_pxi, __pyx_n_s_call_function, 411, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__409)) __PYX_ERR(1, 411, __pyx_L1_error)
-
-  __pyx_tuple__410 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_input_name, __pyx_n_s_value, __pyx_n_s_type); if (unlikely(!__pyx_tuple__410)) __PYX_ERR(1, 438, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__410);
-  __Pyx_GIVEREF(__pyx_tuple__410);
-  __pyx_codeobj__411 = (PyObject*)__Pyx_PyCode_New(3, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__410, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__abstract_pxi, __pyx_n_s_check_opt_input_value, 438, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__411)) __PYX_ERR(1, 438, __pyx_L1_error)
-
-  __pyx_tuple__412 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_input_name, __pyx_n_s_value); if (unlikely(!__pyx_tuple__412)) __PYX_ERR(1, 453, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__412);
-  __Pyx_GIVEREF(__pyx_tuple__412);
-  __pyx_codeobj__413 = (PyObject*)__Pyx_PyCode_New(2, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__412, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__abstract_pxi, __pyx_n_s_get_opt_input_value, 453, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__413)) __PYX_ERR(1, 453, __pyx_L1_error)
-
-  __pyx_tuple__414 = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple__414)) __PYX_ERR(1, 462, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__414);
-  __Pyx_GIVEREF(__pyx_tuple__414);
-  __pyx_codeobj__415 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__414, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__abstract_pxi, __pyx_n_s_repr, 462, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__415)) __PYX_ERR(1, 462, __pyx_L1_error)
-
-  __pyx_tuple__416 = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple__416)) __PYX_ERR(1, 465, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__416);
-  __Pyx_GIVEREF(__pyx_tuple__416);
-  __pyx_codeobj__417 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__416, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__abstract_pxi, __pyx_n_s_unicode, 465, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__417)) __PYX_ERR(1, 465, __pyx_L1_error)
-
-  __pyx_tuple__418 = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple__418)) __PYX_ERR(1, 468, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__418);
-  __Pyx_GIVEREF(__pyx_tuple__418);
-  __pyx_codeobj__419 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__418, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__abstract_pxi, __pyx_n_s_str, 468, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__419)) __PYX_ERR(1, 468, __pyx_L1_error)
-
-  __pyx_tuple__420 = PyTuple_Pack(3, __pyx_n_s_table, __pyx_n_s_groups, __pyx_n_s_i); if (unlikely(!__pyx_tuple__420)) __PYX_ERR(1, 482, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__420);
-  __Pyx_GIVEREF(__pyx_tuple__420);
-  __pyx_codeobj__421 = (PyObject*)__Pyx_PyCode_New(0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__420, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__abstract_pxi, __pyx_n_s_ta_getGroupTable, 482, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__421)) __PYX_ERR(1, 482, __pyx_L1_error)
-
-  __pyx_tuple__422 = PyTuple_Pack(5, __pyx_n_s_group, __pyx_n_s_group, __pyx_n_s_table, __pyx_n_s_functions, __pyx_n_s_i); if (unlikely(!__pyx_tuple__422)) __PYX_ERR(1, 494, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__422);
-  __Pyx_GIVEREF(__pyx_tuple__422);
-  __pyx_codeobj__423 = (PyObject*)__Pyx_PyCode_New(1, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__422, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__abstract_pxi, __pyx_n_s_ta_getFuncTable, 494, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__423)) __PYX_ERR(1, 494, __pyx_L1_error)
-
-  __pyx_tuple__424 = PyTuple_Pack(7, __pyx_n_s_flag, __pyx_n_s_flags_lookup_dict, __pyx_n_s_value_range, __pyx_n_s_min_int, __pyx_n_s_max_int, __pyx_n_s_ret, __pyx_n_s_i); if (unlikely(!__pyx_tuple__424)) __PYX_ERR(1, 506, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__424);
-  __Pyx_GIVEREF(__pyx_tuple__424);
-  __pyx_codeobj__425 = (PyObject*)__Pyx_PyCode_New(2, 0, 7, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__424, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__abstract_pxi, __pyx_n_s_get_flags, 506, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__425)) __PYX_ERR(1, 506, __pyx_L1_error)
-
-  __pyx_tuple__426 = PyTuple_Pack(4, __pyx_n_s_function_name, __pyx_n_s_function_name, __pyx_n_s_info, __pyx_n_s_retCode); if (unlikely(!__pyx_tuple__426)) __PYX_ERR(1, 565, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__426);
-  __Pyx_GIVEREF(__pyx_tuple__426);
-  __pyx_codeobj__427 = (PyObject*)__Pyx_PyCode_New(1, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__426, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__abstract_pxi, __pyx_n_s_ta_getFuncInfo, 565, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__427)) __PYX_ERR(1, 565, __pyx_L1_error)
-
-  __pyx_tuple__428 = PyTuple_Pack(5, __pyx_n_s_function_name, __pyx_n_s_idx, __pyx_n_s_info, __pyx_n_s_retCode, __pyx_n_s_name); if (unlikely(!__pyx_tuple__428)) __PYX_ERR(1, 584, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__428);
-  __Pyx_GIVEREF(__pyx_tuple__428);
-  __pyx_codeobj__429 = (PyObject*)__Pyx_PyCode_New(2, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__428, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__abstract_pxi, __pyx_n_s_ta_getInputParameterInfo, 584, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__429)) __PYX_ERR(1, 584, __pyx_L1_error)
-
-  __pyx_tuple__430 = PyTuple_Pack(6, __pyx_n_s_function_name, __pyx_n_s_idx, __pyx_n_s_info, __pyx_n_s_retCode, __pyx_n_s_name, __pyx_n_s_default_value); if (unlikely(!__pyx_tuple__430)) __PYX_ERR(1, 605, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__430);
-  __Pyx_GIVEREF(__pyx_tuple__430);
-  __pyx_codeobj__431 = (PyObject*)__Pyx_PyCode_New(2, 0, 6, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__430, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__abstract_pxi, __pyx_n_s_ta_getOptInputParameterInfo, 605, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__431)) __PYX_ERR(1, 605, __pyx_L1_error)
-
-  __pyx_tuple__432 = PyTuple_Pack(5, __pyx_n_s_function_name, __pyx_n_s_idx, __pyx_n_s_info, __pyx_n_s_retCode, __pyx_n_s_name); if (unlikely(!__pyx_tuple__432)) __PYX_ERR(1, 629, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__432);
-  __Pyx_GIVEREF(__pyx_tuple__432);
-  __pyx_codeobj__433 = (PyObject*)__Pyx_PyCode_New(2, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__432, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__abstract_pxi, __pyx_n_s_ta_getOutputParameterInfo, 629, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__433)) __PYX_ERR(1, 629, __pyx_L1_error)
-
-  __pyx_tuple__434 = PyTuple_Pack(13, __pyx_n_s_func_info, __pyx_n_s_defaults, __pyx_n_s_func_line, __pyx_n_s_func_args, __pyx_n_s_docs, __pyx_n_s_input_names, __pyx_n_s_input_name, __pyx_n_s_value, __pyx_n_s_params, __pyx_n_s_param, __pyx_n_s_outputs, __pyx_n_s_output, __pyx_n_s_documentation); if (unlikely(!__pyx_tuple__434)) __PYX_ERR(1, 649, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__434);
-  __Pyx_GIVEREF(__pyx_tuple__434);
-  __pyx_codeobj__435 = (PyObject*)__Pyx_PyCode_New(1, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__434, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__abstract_pxi, __pyx_n_s_get_defaults_and_docs, 649, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__435)) __PYX_ERR(1, 649, __pyx_L1_error)
-
-  __pyx_tuple__436 = PyTuple_Pack(7, __pyx_n_s_real, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_real_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__436)) __PYX_ERR(3, 11, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__436);
-  __Pyx_GIVEREF(__pyx_tuple__436);
-  __pyx_codeobj__437 = (PyObject*)__Pyx_PyCode_New(1, 0, 7, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__436, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_ACOS, 11, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__437)) __PYX_ERR(3, 11, __pyx_L1_error)
-
-  __pyx_tuple__438 = PyTuple_Pack(13, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_volume, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_close_data, __pyx_n_s_volume_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__438)) __PYX_ERR(3, 38, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__438);
-  __Pyx_GIVEREF(__pyx_tuple__438);
-  __pyx_codeobj__439 = (PyObject*)__Pyx_PyCode_New(4, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__438, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_AD, 38, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__439)) __PYX_ERR(3, 38, __pyx_L1_error)
-
-  __pyx_tuple__440 = PyTuple_Pack(9, __pyx_n_s_real0, __pyx_n_s_real1, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_real0_data, __pyx_n_s_real1_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__440)) __PYX_ERR(3, 74, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__440);
-  __Pyx_GIVEREF(__pyx_tuple__440);
-  __pyx_codeobj__441 = (PyObject*)__Pyx_PyCode_New(2, 0, 9, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__440, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_ADD, 74, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__441)) __PYX_ERR(3, 74, __pyx_L1_error)
-
-  __pyx_tuple__442 = PyTuple_Pack(15, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_volume, __pyx_n_s_fastperiod, __pyx_n_s_slowperiod, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_close_data, __pyx_n_s_volume_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__442)) __PYX_ERR(3, 105, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__442);
-  __Pyx_GIVEREF(__pyx_tuple__442);
-  __pyx_codeobj__443 = (PyObject*)__Pyx_PyCode_New(6, 0, 15, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__442, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_ADOSC, 105, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__443)) __PYX_ERR(3, 105, __pyx_L1_error)
-
-  __pyx_tuple__444 = PyTuple_Pack(12, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_close_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__444)) __PYX_ERR(3, 144, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__444);
-  __Pyx_GIVEREF(__pyx_tuple__444);
-  __pyx_codeobj__445 = (PyObject*)__Pyx_PyCode_New(4, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__444, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_ADX, 144, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__445)) __PYX_ERR(3, 144, __pyx_L1_error)
-
-  __pyx_tuple__446 = PyTuple_Pack(12, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_close_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__446)) __PYX_ERR(3, 179, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__446);
-  __Pyx_GIVEREF(__pyx_tuple__446);
-  __pyx_codeobj__447 = (PyObject*)__Pyx_PyCode_New(4, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__446, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_ADXR, 179, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__447)) __PYX_ERR(3, 179, __pyx_L1_error)
-
-  __pyx_tuple__448 = PyTuple_Pack(10, __pyx_n_s_real, __pyx_n_s_fastperiod, __pyx_n_s_slowperiod, __pyx_n_s_matype, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_real_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__448)) __PYX_ERR(3, 214, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__448);
-  __Pyx_GIVEREF(__pyx_tuple__448);
-  __pyx_codeobj__449 = (PyObject*)__Pyx_PyCode_New(4, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__448, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_APO, 214, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__449)) __PYX_ERR(3, 214, __pyx_L1_error)
-
-  __pyx_tuple__450 = PyTuple_Pack(11, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outaroondown, __pyx_n_s_outaroonup); if (unlikely(!__pyx_tuple__450)) __PYX_ERR(3, 245, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__450);
-  __Pyx_GIVEREF(__pyx_tuple__450);
-  __pyx_codeobj__451 = (PyObject*)__Pyx_PyCode_New(3, 0, 11, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__450, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_AROON, 245, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__451)) __PYX_ERR(3, 245, __pyx_L1_error)
-
-  __pyx_tuple__452 = PyTuple_Pack(10, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__452)) __PYX_ERR(3, 280, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__452);
-  __Pyx_GIVEREF(__pyx_tuple__452);
-  __pyx_codeobj__453 = (PyObject*)__Pyx_PyCode_New(3, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__452, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_AROONOSC, 280, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__453)) __PYX_ERR(3, 280, __pyx_L1_error)
-
-  __pyx_tuple__454 = PyTuple_Pack(7, __pyx_n_s_real, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_real_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__454)) __PYX_ERR(3, 312, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__454);
-  __Pyx_GIVEREF(__pyx_tuple__454);
-  __pyx_codeobj__455 = (PyObject*)__Pyx_PyCode_New(1, 0, 7, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__454, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_ASIN, 312, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__455)) __PYX_ERR(3, 312, __pyx_L1_error)
-
-  __pyx_tuple__456 = PyTuple_Pack(7, __pyx_n_s_real, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_real_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__456)) __PYX_ERR(3, 339, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__456);
-  __Pyx_GIVEREF(__pyx_tuple__456);
-  __pyx_codeobj__457 = (PyObject*)__Pyx_PyCode_New(1, 0, 7, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__456, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_ATAN, 339, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__457)) __PYX_ERR(3, 339, __pyx_L1_error)
-
-  __pyx_tuple__458 = PyTuple_Pack(12, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_close_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__458)) __PYX_ERR(3, 366, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__458);
-  __Pyx_GIVEREF(__pyx_tuple__458);
-  __pyx_codeobj__459 = (PyObject*)__Pyx_PyCode_New(4, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__458, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_ATR, 366, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__459)) __PYX_ERR(3, 366, __pyx_L1_error)
-
-  __pyx_tuple__460 = PyTuple_Pack(13, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_open_data, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_close_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__460)) __PYX_ERR(3, 401, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__460);
-  __Pyx_GIVEREF(__pyx_tuple__460);
-  __pyx_codeobj__461 = (PyObject*)__Pyx_PyCode_New(4, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__460, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_AVGPRICE, 401, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__461)) __PYX_ERR(3, 401, __pyx_L1_error)
-
-  __pyx_tuple__462 = PyTuple_Pack(13, __pyx_n_s_real, __pyx_n_s_timeperiod, __pyx_n_s_nbdevup, __pyx_n_s_nbdevdn, __pyx_n_s_matype, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_real_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outrealupperband, __pyx_n_s_outrealmiddleband, __pyx_n_s_outreallowerband); if (unlikely(!__pyx_tuple__462)) __PYX_ERR(3, 437, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__462);
-  __Pyx_GIVEREF(__pyx_tuple__462);
-  __pyx_codeobj__463 = (PyObject*)__Pyx_PyCode_New(5, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__462, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_BBANDS, 437, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__463)) __PYX_ERR(3, 437, __pyx_L1_error)
-
-  __pyx_tuple__464 = PyTuple_Pack(10, __pyx_n_s_real0, __pyx_n_s_real1, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_real0_data, __pyx_n_s_real1_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__464)) __PYX_ERR(3, 475, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__464);
-  __Pyx_GIVEREF(__pyx_tuple__464);
-  __pyx_codeobj__465 = (PyObject*)__Pyx_PyCode_New(3, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__464, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_BETA, 475, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__465)) __PYX_ERR(3, 475, __pyx_L1_error)
-
-  __pyx_tuple__466 = PyTuple_Pack(13, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_open_data, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_close_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__466)) __PYX_ERR(3, 508, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__466);
-  __Pyx_GIVEREF(__pyx_tuple__466);
-  __pyx_codeobj__467 = (PyObject*)__Pyx_PyCode_New(4, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__466, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_BOP, 508, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__467)) __PYX_ERR(3, 508, __pyx_L1_error)
-
-  __pyx_tuple__468 = PyTuple_Pack(12, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_close_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__468)) __PYX_ERR(3, 544, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__468);
-  __Pyx_GIVEREF(__pyx_tuple__468);
-  __pyx_codeobj__469 = (PyObject*)__Pyx_PyCode_New(4, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__468, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CCI, 544, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__469)) __PYX_ERR(3, 544, __pyx_L1_error)
-
-  __pyx_tuple__470 = PyTuple_Pack(13, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_open_data, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_close_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__470)) __PYX_ERR(3, 579, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__470);
-  __Pyx_GIVEREF(__pyx_tuple__470);
-  __pyx_codeobj__471 = (PyObject*)__Pyx_PyCode_New(4, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__470, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDL2CROWS, 579, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__471)) __PYX_ERR(3, 579, __pyx_L1_error)
-
-  __pyx_tuple__472 = PyTuple_Pack(13, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_open_data, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_close_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__472)) __PYX_ERR(3, 615, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__472);
-  __Pyx_GIVEREF(__pyx_tuple__472);
-  __pyx_codeobj__473 = (PyObject*)__Pyx_PyCode_New(4, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__472, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDL3BLACKCROWS, 615, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__473)) __PYX_ERR(3, 615, __pyx_L1_error)
-
-  __pyx_tuple__474 = PyTuple_Pack(13, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_open_data, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_close_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__474)) __PYX_ERR(3, 651, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__474);
-  __Pyx_GIVEREF(__pyx_tuple__474);
-  __pyx_codeobj__475 = (PyObject*)__Pyx_PyCode_New(4, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__474, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDL3INSIDE, 651, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__475)) __PYX_ERR(3, 651, __pyx_L1_error)
-
-  __pyx_tuple__476 = PyTuple_Pack(13, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_open_data, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_close_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__476)) __PYX_ERR(3, 687, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__476);
-  __Pyx_GIVEREF(__pyx_tuple__476);
-  __pyx_codeobj__477 = (PyObject*)__Pyx_PyCode_New(4, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__476, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDL3LINESTRIKE, 687, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__477)) __PYX_ERR(3, 687, __pyx_L1_error)
-
-  __pyx_tuple__478 = PyTuple_Pack(13, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_open_data, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_close_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__478)) __PYX_ERR(3, 723, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__478);
-  __Pyx_GIVEREF(__pyx_tuple__478);
-  __pyx_codeobj__479 = (PyObject*)__Pyx_PyCode_New(4, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__478, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDL3OUTSIDE, 723, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__479)) __PYX_ERR(3, 723, __pyx_L1_error)
-
-  __pyx_tuple__480 = PyTuple_Pack(13, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_open_data, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_close_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__480)) __PYX_ERR(3, 759, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__480);
-  __Pyx_GIVEREF(__pyx_tuple__480);
-  __pyx_codeobj__481 = (PyObject*)__Pyx_PyCode_New(4, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__480, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDL3STARSINSOUTH, 759, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__481)) __PYX_ERR(3, 759, __pyx_L1_error)
-
-  __pyx_tuple__482 = PyTuple_Pack(13, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_open_data, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_close_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__482)) __PYX_ERR(3, 795, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__482);
-  __Pyx_GIVEREF(__pyx_tuple__482);
-  __pyx_codeobj__483 = (PyObject*)__Pyx_PyCode_New(4, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__482, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDL3WHITESOLDIERS, 795, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__483)) __PYX_ERR(3, 795, __pyx_L1_error)
-
-  __pyx_tuple__484 = PyTuple_Pack(14, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_penetration, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_open_data, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_close_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__484)) __PYX_ERR(3, 831, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__484);
-  __Pyx_GIVEREF(__pyx_tuple__484);
-  __pyx_codeobj__485 = (PyObject*)__Pyx_PyCode_New(5, 0, 14, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__484, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLABANDONEDBABY, 831, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__485)) __PYX_ERR(3, 831, __pyx_L1_error)
-
-  __pyx_tuple__486 = PyTuple_Pack(13, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_open_data, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_close_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__486)) __PYX_ERR(3, 869, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__486);
-  __Pyx_GIVEREF(__pyx_tuple__486);
-  __pyx_codeobj__487 = (PyObject*)__Pyx_PyCode_New(4, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__486, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLADVANCEBLOCK, 869, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__487)) __PYX_ERR(3, 869, __pyx_L1_error)
-
-  __pyx_tuple__488 = PyTuple_Pack(13, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_open_data, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_close_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__488)) __PYX_ERR(3, 905, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__488);
-  __Pyx_GIVEREF(__pyx_tuple__488);
-  __pyx_codeobj__489 = (PyObject*)__Pyx_PyCode_New(4, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__488, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLBELTHOLD, 905, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__489)) __PYX_ERR(3, 905, __pyx_L1_error)
-
-  __pyx_tuple__490 = PyTuple_Pack(13, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_open_data, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_close_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__490)) __PYX_ERR(3, 941, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__490);
-  __Pyx_GIVEREF(__pyx_tuple__490);
-  __pyx_codeobj__491 = (PyObject*)__Pyx_PyCode_New(4, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__490, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLBREAKAWAY, 941, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__491)) __PYX_ERR(3, 941, __pyx_L1_error)
-
-  __pyx_tuple__492 = PyTuple_Pack(13, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_open_data, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_close_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__492)) __PYX_ERR(3, 977, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__492);
-  __Pyx_GIVEREF(__pyx_tuple__492);
-  __pyx_codeobj__493 = (PyObject*)__Pyx_PyCode_New(4, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__492, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLCLOSINGMARUBOZU, 977, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__493)) __PYX_ERR(3, 977, __pyx_L1_error)
-
-  __pyx_tuple__494 = PyTuple_Pack(13, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_open_data, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_close_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__494)) __PYX_ERR(3, 1013, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__494);
-  __Pyx_GIVEREF(__pyx_tuple__494);
-  __pyx_codeobj__495 = (PyObject*)__Pyx_PyCode_New(4, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__494, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLCONCEALBABYSWALL, 1013, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__495)) __PYX_ERR(3, 1013, __pyx_L1_error)
-
-  __pyx_tuple__496 = PyTuple_Pack(13, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_open_data, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_close_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__496)) __PYX_ERR(3, 1049, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__496);
-  __Pyx_GIVEREF(__pyx_tuple__496);
-  __pyx_codeobj__497 = (PyObject*)__Pyx_PyCode_New(4, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__496, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLCOUNTERATTACK, 1049, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__497)) __PYX_ERR(3, 1049, __pyx_L1_error)
-
-  __pyx_tuple__498 = PyTuple_Pack(14, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_penetration, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_open_data, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_close_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__498)) __PYX_ERR(3, 1085, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__498);
-  __Pyx_GIVEREF(__pyx_tuple__498);
-  __pyx_codeobj__499 = (PyObject*)__Pyx_PyCode_New(5, 0, 14, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__498, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLDARKCLOUDCOVER, 1085, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__499)) __PYX_ERR(3, 1085, __pyx_L1_error)
-
-  __pyx_tuple__500 = PyTuple_Pack(13, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_open_data, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_close_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__500)) __PYX_ERR(3, 1123, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__500);
-  __Pyx_GIVEREF(__pyx_tuple__500);
-  __pyx_codeobj__501 = (PyObject*)__Pyx_PyCode_New(4, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__500, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLDOJI, 1123, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__501)) __PYX_ERR(3, 1123, __pyx_L1_error)
-
-  __pyx_tuple__502 = PyTuple_Pack(13, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_open_data, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_close_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__502)) __PYX_ERR(3, 1159, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__502);
-  __Pyx_GIVEREF(__pyx_tuple__502);
-  __pyx_codeobj__503 = (PyObject*)__Pyx_PyCode_New(4, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__502, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLDOJISTAR, 1159, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__503)) __PYX_ERR(3, 1159, __pyx_L1_error)
-
-  __pyx_tuple__504 = PyTuple_Pack(13, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_open_data, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_close_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__504)) __PYX_ERR(3, 1195, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__504);
-  __Pyx_GIVEREF(__pyx_tuple__504);
-  __pyx_codeobj__505 = (PyObject*)__Pyx_PyCode_New(4, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__504, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLDRAGONFLYDOJI, 1195, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__505)) __PYX_ERR(3, 1195, __pyx_L1_error)
-
-  __pyx_tuple__506 = PyTuple_Pack(13, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_open_data, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_close_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__506)) __PYX_ERR(3, 1231, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__506);
-  __Pyx_GIVEREF(__pyx_tuple__506);
-  __pyx_codeobj__507 = (PyObject*)__Pyx_PyCode_New(4, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__506, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLENGULFING, 1231, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__507)) __PYX_ERR(3, 1231, __pyx_L1_error)
-
-  __pyx_tuple__508 = PyTuple_Pack(14, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_penetration, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_open_data, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_close_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__508)) __PYX_ERR(3, 1267, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__508);
-  __Pyx_GIVEREF(__pyx_tuple__508);
-  __pyx_codeobj__509 = (PyObject*)__Pyx_PyCode_New(5, 0, 14, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__508, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLEVENINGDOJISTAR, 1267, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__509)) __PYX_ERR(3, 1267, __pyx_L1_error)
-
-  __pyx_tuple__510 = PyTuple_Pack(14, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_penetration, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_open_data, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_close_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__510)) __PYX_ERR(3, 1305, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__510);
-  __Pyx_GIVEREF(__pyx_tuple__510);
-  __pyx_codeobj__511 = (PyObject*)__Pyx_PyCode_New(5, 0, 14, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__510, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLEVENINGSTAR, 1305, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__511)) __PYX_ERR(3, 1305, __pyx_L1_error)
-
-  __pyx_tuple__512 = PyTuple_Pack(13, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_open_data, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_close_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__512)) __PYX_ERR(3, 1343, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__512);
-  __Pyx_GIVEREF(__pyx_tuple__512);
-  __pyx_codeobj__513 = (PyObject*)__Pyx_PyCode_New(4, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__512, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLGAPSIDESIDEWHITE, 1343, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__513)) __PYX_ERR(3, 1343, __pyx_L1_error)
-
-  __pyx_tuple__514 = PyTuple_Pack(13, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_open_data, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_close_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__514)) __PYX_ERR(3, 1379, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__514);
-  __Pyx_GIVEREF(__pyx_tuple__514);
-  __pyx_codeobj__515 = (PyObject*)__Pyx_PyCode_New(4, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__514, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLGRAVESTONEDOJI, 1379, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__515)) __PYX_ERR(3, 1379, __pyx_L1_error)
-
-  __pyx_tuple__516 = PyTuple_Pack(13, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_open_data, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_close_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__516)) __PYX_ERR(3, 1415, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__516);
-  __Pyx_GIVEREF(__pyx_tuple__516);
-  __pyx_codeobj__517 = (PyObject*)__Pyx_PyCode_New(4, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__516, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLHAMMER, 1415, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__517)) __PYX_ERR(3, 1415, __pyx_L1_error)
-
-  __pyx_tuple__518 = PyTuple_Pack(13, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_open_data, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_close_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__518)) __PYX_ERR(3, 1451, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__518);
-  __Pyx_GIVEREF(__pyx_tuple__518);
-  __pyx_codeobj__519 = (PyObject*)__Pyx_PyCode_New(4, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__518, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLHANGINGMAN, 1451, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__519)) __PYX_ERR(3, 1451, __pyx_L1_error)
-
-  __pyx_tuple__520 = PyTuple_Pack(13, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_open_data, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_close_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__520)) __PYX_ERR(3, 1487, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__520);
-  __Pyx_GIVEREF(__pyx_tuple__520);
-  __pyx_codeobj__521 = (PyObject*)__Pyx_PyCode_New(4, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__520, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLHARAMI, 1487, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__521)) __PYX_ERR(3, 1487, __pyx_L1_error)
-
-  __pyx_tuple__522 = PyTuple_Pack(13, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_open_data, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_close_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__522)) __PYX_ERR(3, 1523, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__522);
-  __Pyx_GIVEREF(__pyx_tuple__522);
-  __pyx_codeobj__523 = (PyObject*)__Pyx_PyCode_New(4, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__522, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLHARAMICROSS, 1523, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__523)) __PYX_ERR(3, 1523, __pyx_L1_error)
-
-  __pyx_tuple__524 = PyTuple_Pack(13, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_open_data, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_close_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__524)) __PYX_ERR(3, 1559, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__524);
-  __Pyx_GIVEREF(__pyx_tuple__524);
-  __pyx_codeobj__525 = (PyObject*)__Pyx_PyCode_New(4, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__524, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLHIGHWAVE, 1559, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__525)) __PYX_ERR(3, 1559, __pyx_L1_error)
-
-  __pyx_tuple__526 = PyTuple_Pack(13, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_open_data, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_close_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__526)) __PYX_ERR(3, 1595, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__526);
-  __Pyx_GIVEREF(__pyx_tuple__526);
-  __pyx_codeobj__527 = (PyObject*)__Pyx_PyCode_New(4, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__526, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLHIKKAKE, 1595, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__527)) __PYX_ERR(3, 1595, __pyx_L1_error)
-
-  __pyx_tuple__528 = PyTuple_Pack(13, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_open_data, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_close_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__528)) __PYX_ERR(3, 1631, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__528);
-  __Pyx_GIVEREF(__pyx_tuple__528);
-  __pyx_codeobj__529 = (PyObject*)__Pyx_PyCode_New(4, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__528, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLHIKKAKEMOD, 1631, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__529)) __PYX_ERR(3, 1631, __pyx_L1_error)
-
-  __pyx_tuple__530 = PyTuple_Pack(13, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_open_data, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_close_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__530)) __PYX_ERR(3, 1667, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__530);
-  __Pyx_GIVEREF(__pyx_tuple__530);
-  __pyx_codeobj__531 = (PyObject*)__Pyx_PyCode_New(4, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__530, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLHOMINGPIGEON, 1667, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__531)) __PYX_ERR(3, 1667, __pyx_L1_error)
-
-  __pyx_tuple__532 = PyTuple_Pack(13, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_open_data, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_close_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__532)) __PYX_ERR(3, 1703, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__532);
-  __Pyx_GIVEREF(__pyx_tuple__532);
-  __pyx_codeobj__533 = (PyObject*)__Pyx_PyCode_New(4, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__532, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLIDENTICAL3CROWS, 1703, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__533)) __PYX_ERR(3, 1703, __pyx_L1_error)
-
-  __pyx_tuple__534 = PyTuple_Pack(13, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_open_data, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_close_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__534)) __PYX_ERR(3, 1739, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__534);
-  __Pyx_GIVEREF(__pyx_tuple__534);
-  __pyx_codeobj__535 = (PyObject*)__Pyx_PyCode_New(4, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__534, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLINNECK, 1739, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__535)) __PYX_ERR(3, 1739, __pyx_L1_error)
-
-  __pyx_tuple__536 = PyTuple_Pack(13, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_open_data, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_close_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__536)) __PYX_ERR(3, 1775, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__536);
-  __Pyx_GIVEREF(__pyx_tuple__536);
-  __pyx_codeobj__537 = (PyObject*)__Pyx_PyCode_New(4, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__536, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLINVERTEDHAMMER, 1775, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__537)) __PYX_ERR(3, 1775, __pyx_L1_error)
-
-  __pyx_tuple__538 = PyTuple_Pack(13, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_open_data, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_close_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__538)) __PYX_ERR(3, 1811, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__538);
-  __Pyx_GIVEREF(__pyx_tuple__538);
-  __pyx_codeobj__539 = (PyObject*)__Pyx_PyCode_New(4, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__538, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLKICKING, 1811, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__539)) __PYX_ERR(3, 1811, __pyx_L1_error)
-
-  __pyx_tuple__540 = PyTuple_Pack(13, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_open_data, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_close_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__540)) __PYX_ERR(3, 1847, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__540);
-  __Pyx_GIVEREF(__pyx_tuple__540);
-  __pyx_codeobj__541 = (PyObject*)__Pyx_PyCode_New(4, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__540, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLKICKINGBYLENGTH, 1847, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__541)) __PYX_ERR(3, 1847, __pyx_L1_error)
-
-  __pyx_tuple__542 = PyTuple_Pack(13, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_open_data, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_close_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__542)) __PYX_ERR(3, 1883, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__542);
-  __Pyx_GIVEREF(__pyx_tuple__542);
-  __pyx_codeobj__543 = (PyObject*)__Pyx_PyCode_New(4, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__542, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLLADDERBOTTOM, 1883, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__543)) __PYX_ERR(3, 1883, __pyx_L1_error)
-
-  __pyx_tuple__544 = PyTuple_Pack(13, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_open_data, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_close_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__544)) __PYX_ERR(3, 1919, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__544);
-  __Pyx_GIVEREF(__pyx_tuple__544);
-  __pyx_codeobj__545 = (PyObject*)__Pyx_PyCode_New(4, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__544, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLLONGLEGGEDDOJI, 1919, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__545)) __PYX_ERR(3, 1919, __pyx_L1_error)
-
-  __pyx_tuple__546 = PyTuple_Pack(13, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_open_data, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_close_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__546)) __PYX_ERR(3, 1955, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__546);
-  __Pyx_GIVEREF(__pyx_tuple__546);
-  __pyx_codeobj__547 = (PyObject*)__Pyx_PyCode_New(4, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__546, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLLONGLINE, 1955, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__547)) __PYX_ERR(3, 1955, __pyx_L1_error)
-
-  __pyx_tuple__548 = PyTuple_Pack(13, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_open_data, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_close_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__548)) __PYX_ERR(3, 1991, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__548);
-  __Pyx_GIVEREF(__pyx_tuple__548);
-  __pyx_codeobj__549 = (PyObject*)__Pyx_PyCode_New(4, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__548, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLMARUBOZU, 1991, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__549)) __PYX_ERR(3, 1991, __pyx_L1_error)
-
-  __pyx_tuple__550 = PyTuple_Pack(13, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_open_data, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_close_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__550)) __PYX_ERR(3, 2027, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__550);
-  __Pyx_GIVEREF(__pyx_tuple__550);
-  __pyx_codeobj__551 = (PyObject*)__Pyx_PyCode_New(4, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__550, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLMATCHINGLOW, 2027, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__551)) __PYX_ERR(3, 2027, __pyx_L1_error)
-
-  __pyx_tuple__552 = PyTuple_Pack(14, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_penetration, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_open_data, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_close_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__552)) __PYX_ERR(3, 2063, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__552);
-  __Pyx_GIVEREF(__pyx_tuple__552);
-  __pyx_codeobj__553 = (PyObject*)__Pyx_PyCode_New(5, 0, 14, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__552, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLMATHOLD, 2063, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__553)) __PYX_ERR(3, 2063, __pyx_L1_error)
-
-  __pyx_tuple__554 = PyTuple_Pack(14, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_penetration, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_open_data, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_close_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__554)) __PYX_ERR(3, 2101, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__554);
-  __Pyx_GIVEREF(__pyx_tuple__554);
-  __pyx_codeobj__555 = (PyObject*)__Pyx_PyCode_New(5, 0, 14, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__554, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLMORNINGDOJISTAR, 2101, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__555)) __PYX_ERR(3, 2101, __pyx_L1_error)
-
-  __pyx_tuple__556 = PyTuple_Pack(14, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_penetration, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_open_data, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_close_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__556)) __PYX_ERR(3, 2139, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__556);
-  __Pyx_GIVEREF(__pyx_tuple__556);
-  __pyx_codeobj__557 = (PyObject*)__Pyx_PyCode_New(5, 0, 14, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__556, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLMORNINGSTAR, 2139, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__557)) __PYX_ERR(3, 2139, __pyx_L1_error)
-
-  __pyx_tuple__558 = PyTuple_Pack(13, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_open_data, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_close_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__558)) __PYX_ERR(3, 2177, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__558);
-  __Pyx_GIVEREF(__pyx_tuple__558);
-  __pyx_codeobj__559 = (PyObject*)__Pyx_PyCode_New(4, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__558, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLONNECK, 2177, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__559)) __PYX_ERR(3, 2177, __pyx_L1_error)
-
-  __pyx_tuple__560 = PyTuple_Pack(13, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_open_data, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_close_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__560)) __PYX_ERR(3, 2213, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__560);
-  __Pyx_GIVEREF(__pyx_tuple__560);
-  __pyx_codeobj__561 = (PyObject*)__Pyx_PyCode_New(4, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__560, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLPIERCING, 2213, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__561)) __PYX_ERR(3, 2213, __pyx_L1_error)
-
-  __pyx_tuple__562 = PyTuple_Pack(13, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_open_data, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_close_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__562)) __PYX_ERR(3, 2249, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__562);
-  __Pyx_GIVEREF(__pyx_tuple__562);
-  __pyx_codeobj__563 = (PyObject*)__Pyx_PyCode_New(4, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__562, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLRICKSHAWMAN, 2249, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__563)) __PYX_ERR(3, 2249, __pyx_L1_error)
-
-  __pyx_tuple__564 = PyTuple_Pack(13, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_open_data, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_close_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__564)) __PYX_ERR(3, 2285, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__564);
-  __Pyx_GIVEREF(__pyx_tuple__564);
-  __pyx_codeobj__565 = (PyObject*)__Pyx_PyCode_New(4, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__564, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLRISEFALL3METHODS, 2285, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__565)) __PYX_ERR(3, 2285, __pyx_L1_error)
-
-  __pyx_tuple__566 = PyTuple_Pack(13, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_open_data, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_close_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__566)) __PYX_ERR(3, 2321, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__566);
-  __Pyx_GIVEREF(__pyx_tuple__566);
-  __pyx_codeobj__567 = (PyObject*)__Pyx_PyCode_New(4, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__566, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLSEPARATINGLINES, 2321, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__567)) __PYX_ERR(3, 2321, __pyx_L1_error)
-
-  __pyx_tuple__568 = PyTuple_Pack(13, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_open_data, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_close_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__568)) __PYX_ERR(3, 2357, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__568);
-  __Pyx_GIVEREF(__pyx_tuple__568);
-  __pyx_codeobj__569 = (PyObject*)__Pyx_PyCode_New(4, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__568, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLSHOOTINGSTAR, 2357, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__569)) __PYX_ERR(3, 2357, __pyx_L1_error)
-
-  __pyx_tuple__570 = PyTuple_Pack(13, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_open_data, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_close_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__570)) __PYX_ERR(3, 2393, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__570);
-  __Pyx_GIVEREF(__pyx_tuple__570);
-  __pyx_codeobj__571 = (PyObject*)__Pyx_PyCode_New(4, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__570, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLSHORTLINE, 2393, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__571)) __PYX_ERR(3, 2393, __pyx_L1_error)
-
-  __pyx_tuple__572 = PyTuple_Pack(13, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_open_data, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_close_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__572)) __PYX_ERR(3, 2429, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__572);
-  __Pyx_GIVEREF(__pyx_tuple__572);
-  __pyx_codeobj__573 = (PyObject*)__Pyx_PyCode_New(4, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__572, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLSPINNINGTOP, 2429, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__573)) __PYX_ERR(3, 2429, __pyx_L1_error)
-
-  __pyx_tuple__574 = PyTuple_Pack(13, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_open_data, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_close_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__574)) __PYX_ERR(3, 2465, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__574);
-  __Pyx_GIVEREF(__pyx_tuple__574);
-  __pyx_codeobj__575 = (PyObject*)__Pyx_PyCode_New(4, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__574, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLSTALLEDPATTERN, 2465, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__575)) __PYX_ERR(3, 2465, __pyx_L1_error)
-
-  __pyx_tuple__576 = PyTuple_Pack(13, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_open_data, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_close_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__576)) __PYX_ERR(3, 2501, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__576);
-  __Pyx_GIVEREF(__pyx_tuple__576);
-  __pyx_codeobj__577 = (PyObject*)__Pyx_PyCode_New(4, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__576, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLSTICKSANDWICH, 2501, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__577)) __PYX_ERR(3, 2501, __pyx_L1_error)
-
-  __pyx_tuple__578 = PyTuple_Pack(13, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_open_data, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_close_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__578)) __PYX_ERR(3, 2537, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__578);
-  __Pyx_GIVEREF(__pyx_tuple__578);
-  __pyx_codeobj__579 = (PyObject*)__Pyx_PyCode_New(4, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__578, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLTAKURI, 2537, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__579)) __PYX_ERR(3, 2537, __pyx_L1_error)
-
-  __pyx_tuple__580 = PyTuple_Pack(13, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_open_data, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_close_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__580)) __PYX_ERR(3, 2573, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__580);
-  __Pyx_GIVEREF(__pyx_tuple__580);
-  __pyx_codeobj__581 = (PyObject*)__Pyx_PyCode_New(4, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__580, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLTASUKIGAP, 2573, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__581)) __PYX_ERR(3, 2573, __pyx_L1_error)
-
-  __pyx_tuple__582 = PyTuple_Pack(13, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_open_data, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_close_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__582)) __PYX_ERR(3, 2609, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__582);
-  __Pyx_GIVEREF(__pyx_tuple__582);
-  __pyx_codeobj__583 = (PyObject*)__Pyx_PyCode_New(4, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__582, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLTHRUSTING, 2609, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__583)) __PYX_ERR(3, 2609, __pyx_L1_error)
-
-  __pyx_tuple__584 = PyTuple_Pack(13, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_open_data, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_close_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__584)) __PYX_ERR(3, 2645, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__584);
-  __Pyx_GIVEREF(__pyx_tuple__584);
-  __pyx_codeobj__585 = (PyObject*)__Pyx_PyCode_New(4, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__584, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLTRISTAR, 2645, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__585)) __PYX_ERR(3, 2645, __pyx_L1_error)
-
-  __pyx_tuple__586 = PyTuple_Pack(13, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_open_data, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_close_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__586)) __PYX_ERR(3, 2681, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__586);
-  __Pyx_GIVEREF(__pyx_tuple__586);
-  __pyx_codeobj__587 = (PyObject*)__Pyx_PyCode_New(4, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__586, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLUNIQUE3RIVER, 2681, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__587)) __PYX_ERR(3, 2681, __pyx_L1_error)
-
-  __pyx_tuple__588 = PyTuple_Pack(13, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_open_data, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_close_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__588)) __PYX_ERR(3, 2717, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__588);
-  __Pyx_GIVEREF(__pyx_tuple__588);
-  __pyx_codeobj__589 = (PyObject*)__Pyx_PyCode_New(4, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__588, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLUPSIDEGAP2CROWS, 2717, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__589)) __PYX_ERR(3, 2717, __pyx_L1_error)
-
-  __pyx_tuple__590 = PyTuple_Pack(13, __pyx_n_s_open, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_open_data, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_close_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__590)) __PYX_ERR(3, 2753, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__590);
-  __Pyx_GIVEREF(__pyx_tuple__590);
-  __pyx_codeobj__591 = (PyObject*)__Pyx_PyCode_New(4, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__590, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CDLXSIDEGAP3METHODS, 2753, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__591)) __PYX_ERR(3, 2753, __pyx_L1_error)
-
-  __pyx_tuple__592 = PyTuple_Pack(7, __pyx_n_s_real, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_real_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__592)) __PYX_ERR(3, 2789, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__592);
-  __Pyx_GIVEREF(__pyx_tuple__592);
-  __pyx_codeobj__593 = (PyObject*)__Pyx_PyCode_New(1, 0, 7, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__592, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CEIL, 2789, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__593)) __PYX_ERR(3, 2789, __pyx_L1_error)
-
-  __pyx_tuple__594 = PyTuple_Pack(8, __pyx_n_s_real, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_real_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__594)) __PYX_ERR(3, 2816, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__594);
-  __Pyx_GIVEREF(__pyx_tuple__594);
-  __pyx_codeobj__595 = (PyObject*)__Pyx_PyCode_New(2, 0, 8, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__594, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CMO, 2816, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__595)) __PYX_ERR(3, 2816, __pyx_L1_error)
-
-  __pyx_tuple__596 = PyTuple_Pack(10, __pyx_n_s_real0, __pyx_n_s_real1, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_real0_data, __pyx_n_s_real1_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__596)) __PYX_ERR(3, 2845, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__596);
-  __Pyx_GIVEREF(__pyx_tuple__596);
-  __pyx_codeobj__597 = (PyObject*)__Pyx_PyCode_New(3, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__596, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_CORREL, 2845, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__597)) __PYX_ERR(3, 2845, __pyx_L1_error)
-
-  __pyx_tuple__598 = PyTuple_Pack(7, __pyx_n_s_real, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_real_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__598)) __PYX_ERR(3, 2878, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__598);
-  __Pyx_GIVEREF(__pyx_tuple__598);
-  __pyx_codeobj__599 = (PyObject*)__Pyx_PyCode_New(1, 0, 7, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__598, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_COS, 2878, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__599)) __PYX_ERR(3, 2878, __pyx_L1_error)
-
-  __pyx_tuple__600 = PyTuple_Pack(7, __pyx_n_s_real, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_real_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__600)) __PYX_ERR(3, 2905, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__600);
-  __Pyx_GIVEREF(__pyx_tuple__600);
-  __pyx_codeobj__601 = (PyObject*)__Pyx_PyCode_New(1, 0, 7, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__600, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_COSH, 2905, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__601)) __PYX_ERR(3, 2905, __pyx_L1_error)
-
-  __pyx_tuple__602 = PyTuple_Pack(8, __pyx_n_s_real, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_real_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__602)) __PYX_ERR(3, 2932, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__602);
-  __Pyx_GIVEREF(__pyx_tuple__602);
-  __pyx_codeobj__603 = (PyObject*)__Pyx_PyCode_New(2, 0, 8, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__602, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_DEMA, 2932, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__603)) __PYX_ERR(3, 2932, __pyx_L1_error)
-
-  __pyx_tuple__604 = PyTuple_Pack(9, __pyx_n_s_real0, __pyx_n_s_real1, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_real0_data, __pyx_n_s_real1_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__604)) __PYX_ERR(3, 2961, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__604);
-  __Pyx_GIVEREF(__pyx_tuple__604);
-  __pyx_codeobj__605 = (PyObject*)__Pyx_PyCode_New(2, 0, 9, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__604, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_DIV, 2961, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__605)) __PYX_ERR(3, 2961, __pyx_L1_error)
-
-  __pyx_tuple__606 = PyTuple_Pack(12, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_close_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__606)) __PYX_ERR(3, 2992, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__606);
-  __Pyx_GIVEREF(__pyx_tuple__606);
-  __pyx_codeobj__607 = (PyObject*)__Pyx_PyCode_New(4, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__606, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_DX, 2992, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__607)) __PYX_ERR(3, 2992, __pyx_L1_error)
-
-  __pyx_tuple__608 = PyTuple_Pack(8, __pyx_n_s_real, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_real_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__608)) __PYX_ERR(3, 3027, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__608);
-  __Pyx_GIVEREF(__pyx_tuple__608);
-  __pyx_codeobj__609 = (PyObject*)__Pyx_PyCode_New(2, 0, 8, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__608, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_EMA, 3027, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__609)) __PYX_ERR(3, 3027, __pyx_L1_error)
-
-  __pyx_tuple__610 = PyTuple_Pack(7, __pyx_n_s_real, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_real_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__610)) __PYX_ERR(3, 3056, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__610);
-  __Pyx_GIVEREF(__pyx_tuple__610);
-  __pyx_codeobj__611 = (PyObject*)__Pyx_PyCode_New(1, 0, 7, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__610, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_EXP, 3056, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__611)) __PYX_ERR(3, 3056, __pyx_L1_error)
-
-  __pyx_tuple__612 = PyTuple_Pack(7, __pyx_n_s_real, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_real_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__612)) __PYX_ERR(3, 3083, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__612);
-  __Pyx_GIVEREF(__pyx_tuple__612);
-  __pyx_codeobj__613 = (PyObject*)__Pyx_PyCode_New(1, 0, 7, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__612, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_FLOOR, 3083, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__613)) __PYX_ERR(3, 3083, __pyx_L1_error)
-
-  __pyx_tuple__614 = PyTuple_Pack(7, __pyx_n_s_real, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_real_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__614)) __PYX_ERR(3, 3110, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__614);
-  __Pyx_GIVEREF(__pyx_tuple__614);
-  __pyx_codeobj__615 = (PyObject*)__Pyx_PyCode_New(1, 0, 7, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__614, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_HT_DCPERIOD, 3110, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__615)) __PYX_ERR(3, 3110, __pyx_L1_error)
-
-  __pyx_tuple__616 = PyTuple_Pack(7, __pyx_n_s_real, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_real_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__616)) __PYX_ERR(3, 3137, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__616);
-  __Pyx_GIVEREF(__pyx_tuple__616);
-  __pyx_codeobj__617 = (PyObject*)__Pyx_PyCode_New(1, 0, 7, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__616, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_HT_DCPHASE, 3137, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__617)) __PYX_ERR(3, 3137, __pyx_L1_error)
-
-  __pyx_tuple__618 = PyTuple_Pack(8, __pyx_n_s_real, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_real_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinphase, __pyx_n_s_outquadrature); if (unlikely(!__pyx_tuple__618)) __PYX_ERR(3, 3164, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__618);
-  __Pyx_GIVEREF(__pyx_tuple__618);
-  __pyx_codeobj__619 = (PyObject*)__Pyx_PyCode_New(1, 0, 8, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__618, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_HT_PHASOR, 3164, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__619)) __PYX_ERR(3, 3164, __pyx_L1_error)
-
-  __pyx_tuple__620 = PyTuple_Pack(8, __pyx_n_s_real, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_real_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outsine, __pyx_n_s_outleadsine); if (unlikely(!__pyx_tuple__620)) __PYX_ERR(3, 3194, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__620);
-  __Pyx_GIVEREF(__pyx_tuple__620);
-  __pyx_codeobj__621 = (PyObject*)__Pyx_PyCode_New(1, 0, 8, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__620, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_HT_SINE, 3194, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__621)) __PYX_ERR(3, 3194, __pyx_L1_error)
-
-  __pyx_tuple__622 = PyTuple_Pack(7, __pyx_n_s_real, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_real_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__622)) __PYX_ERR(3, 3224, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__622);
-  __Pyx_GIVEREF(__pyx_tuple__622);
-  __pyx_codeobj__623 = (PyObject*)__Pyx_PyCode_New(1, 0, 7, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__622, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_HT_TRENDLINE, 3224, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__623)) __PYX_ERR(3, 3224, __pyx_L1_error)
-
-  __pyx_tuple__624 = PyTuple_Pack(7, __pyx_n_s_real, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_real_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__624)) __PYX_ERR(3, 3251, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__624);
-  __Pyx_GIVEREF(__pyx_tuple__624);
-  __pyx_codeobj__625 = (PyObject*)__Pyx_PyCode_New(1, 0, 7, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__624, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_HT_TRENDMODE, 3251, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__625)) __PYX_ERR(3, 3251, __pyx_L1_error)
-
-  __pyx_tuple__626 = PyTuple_Pack(8, __pyx_n_s_real, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_real_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__626)) __PYX_ERR(3, 3278, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__626);
-  __Pyx_GIVEREF(__pyx_tuple__626);
-  __pyx_codeobj__627 = (PyObject*)__Pyx_PyCode_New(2, 0, 8, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__626, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_KAMA, 3278, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__627)) __PYX_ERR(3, 3278, __pyx_L1_error)
-
-  __pyx_tuple__628 = PyTuple_Pack(8, __pyx_n_s_real, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_real_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__628)) __PYX_ERR(3, 3307, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__628);
-  __Pyx_GIVEREF(__pyx_tuple__628);
-  __pyx_codeobj__629 = (PyObject*)__Pyx_PyCode_New(2, 0, 8, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__628, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_LINEARREG, 3307, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__629)) __PYX_ERR(3, 3307, __pyx_L1_error)
-
-  __pyx_tuple__630 = PyTuple_Pack(8, __pyx_n_s_real, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_real_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__630)) __PYX_ERR(3, 3336, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__630);
-  __Pyx_GIVEREF(__pyx_tuple__630);
-  __pyx_codeobj__631 = (PyObject*)__Pyx_PyCode_New(2, 0, 8, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__630, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_LINEARREG_ANGLE, 3336, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__631)) __PYX_ERR(3, 3336, __pyx_L1_error)
-
-  __pyx_tuple__632 = PyTuple_Pack(8, __pyx_n_s_real, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_real_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__632)) __PYX_ERR(3, 3365, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__632);
-  __Pyx_GIVEREF(__pyx_tuple__632);
-  __pyx_codeobj__633 = (PyObject*)__Pyx_PyCode_New(2, 0, 8, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__632, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_LINEARREG_INTERCEPT, 3365, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__633)) __PYX_ERR(3, 3365, __pyx_L1_error)
-
-  __pyx_tuple__634 = PyTuple_Pack(8, __pyx_n_s_real, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_real_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__634)) __PYX_ERR(3, 3394, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__634);
-  __Pyx_GIVEREF(__pyx_tuple__634);
-  __pyx_codeobj__635 = (PyObject*)__Pyx_PyCode_New(2, 0, 8, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__634, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_LINEARREG_SLOPE, 3394, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__635)) __PYX_ERR(3, 3394, __pyx_L1_error)
-
-  __pyx_tuple__636 = PyTuple_Pack(7, __pyx_n_s_real, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_real_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__636)) __PYX_ERR(3, 3423, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__636);
-  __Pyx_GIVEREF(__pyx_tuple__636);
-  __pyx_codeobj__637 = (PyObject*)__Pyx_PyCode_New(1, 0, 7, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__636, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_LN, 3423, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__637)) __PYX_ERR(3, 3423, __pyx_L1_error)
-
-  __pyx_tuple__638 = PyTuple_Pack(7, __pyx_n_s_real, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_real_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__638)) __PYX_ERR(3, 3450, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__638);
-  __Pyx_GIVEREF(__pyx_tuple__638);
-  __pyx_codeobj__639 = (PyObject*)__Pyx_PyCode_New(1, 0, 7, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__638, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_LOG10, 3450, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__639)) __PYX_ERR(3, 3450, __pyx_L1_error)
-
-  __pyx_tuple__640 = PyTuple_Pack(9, __pyx_n_s_real, __pyx_n_s_timeperiod, __pyx_n_s_matype, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_real_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__640)) __PYX_ERR(3, 3477, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__640);
-  __Pyx_GIVEREF(__pyx_tuple__640);
-  __pyx_codeobj__641 = (PyObject*)__Pyx_PyCode_New(3, 0, 9, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__640, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_MA, 3477, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__641)) __PYX_ERR(3, 3477, __pyx_L1_error)
-
-  __pyx_tuple__642 = PyTuple_Pack(12, __pyx_n_s_real, __pyx_n_s_fastperiod, __pyx_n_s_slowperiod, __pyx_n_s_signalperiod, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_real_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outmacd, __pyx_n_s_outmacdsignal, __pyx_n_s_outmacdhist); if (unlikely(!__pyx_tuple__642)) __PYX_ERR(3, 3507, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__642);
-  __Pyx_GIVEREF(__pyx_tuple__642);
-  __pyx_codeobj__643 = (PyObject*)__Pyx_PyCode_New(4, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__642, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_MACD, 3507, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__643)) __PYX_ERR(3, 3507, __pyx_L1_error)
-
-  __pyx_tuple__644 = PyTuple_Pack(15, __pyx_n_s_real, __pyx_n_s_fastperiod, __pyx_n_s_fastmatype, __pyx_n_s_slowperiod, __pyx_n_s_slowmatype, __pyx_n_s_signalperiod, __pyx_n_s_signalmatype, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_real_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outmacd, __pyx_n_s_outmacdsignal, __pyx_n_s_outmacdhist); if (unlikely(!__pyx_tuple__644)) __PYX_ERR(3, 3544, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__644);
-  __Pyx_GIVEREF(__pyx_tuple__644);
-  __pyx_codeobj__645 = (PyObject*)__Pyx_PyCode_New(7, 0, 15, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__644, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_MACDEXT, 3544, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__645)) __PYX_ERR(3, 3544, __pyx_L1_error)
-
-  __pyx_tuple__646 = PyTuple_Pack(10, __pyx_n_s_real, __pyx_n_s_signalperiod, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_real_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outmacd, __pyx_n_s_outmacdsignal, __pyx_n_s_outmacdhist); if (unlikely(!__pyx_tuple__646)) __PYX_ERR(3, 3584, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__646);
-  __Pyx_GIVEREF(__pyx_tuple__646);
-  __pyx_codeobj__647 = (PyObject*)__Pyx_PyCode_New(2, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__646, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_MACDFIX, 3584, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__647)) __PYX_ERR(3, 3584, __pyx_L1_error)
-
-  __pyx_tuple__648 = PyTuple_Pack(10, __pyx_n_s_real, __pyx_n_s_fastlimit, __pyx_n_s_slowlimit, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_real_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outmama, __pyx_n_s_outfama); if (unlikely(!__pyx_tuple__648)) __PYX_ERR(3, 3619, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__648);
-  __Pyx_GIVEREF(__pyx_tuple__648);
-  __pyx_codeobj__649 = (PyObject*)__Pyx_PyCode_New(3, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__648, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_MAMA, 3619, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__649)) __PYX_ERR(3, 3619, __pyx_L1_error)
-
-  __pyx_tuple__650 = PyTuple_Pack(12, __pyx_n_s_real, __pyx_n_s_periods, __pyx_n_s_minperiod, __pyx_n_s_maxperiod, __pyx_n_s_matype, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_real_data, __pyx_n_s_periods_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__650)) __PYX_ERR(3, 3652, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__650);
-  __Pyx_GIVEREF(__pyx_tuple__650);
-  __pyx_codeobj__651 = (PyObject*)__Pyx_PyCode_New(5, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__650, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_MAVP, 3652, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__651)) __PYX_ERR(3, 3652, __pyx_L1_error)
-
-  __pyx_tuple__652 = PyTuple_Pack(8, __pyx_n_s_real, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_real_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__652)) __PYX_ERR(3, 3687, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__652);
-  __Pyx_GIVEREF(__pyx_tuple__652);
-  __pyx_codeobj__653 = (PyObject*)__Pyx_PyCode_New(2, 0, 8, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__652, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_MAX, 3687, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__653)) __PYX_ERR(3, 3687, __pyx_L1_error)
-
-  __pyx_tuple__654 = PyTuple_Pack(8, __pyx_n_s_real, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_real_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__654)) __PYX_ERR(3, 3716, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__654);
-  __Pyx_GIVEREF(__pyx_tuple__654);
-  __pyx_codeobj__655 = (PyObject*)__Pyx_PyCode_New(2, 0, 8, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__654, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_MAXINDEX, 3716, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__655)) __PYX_ERR(3, 3716, __pyx_L1_error)
-
-  __pyx_tuple__656 = PyTuple_Pack(9, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__656)) __PYX_ERR(3, 3745, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__656);
-  __Pyx_GIVEREF(__pyx_tuple__656);
-  __pyx_codeobj__657 = (PyObject*)__Pyx_PyCode_New(2, 0, 9, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__656, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_MEDPRICE, 3745, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__657)) __PYX_ERR(3, 3745, __pyx_L1_error)
-
-  __pyx_tuple__658 = PyTuple_Pack(14, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_volume, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_close_data, __pyx_n_s_volume_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__658)) __PYX_ERR(3, 3775, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__658);
-  __Pyx_GIVEREF(__pyx_tuple__658);
-  __pyx_codeobj__659 = (PyObject*)__Pyx_PyCode_New(5, 0, 14, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__658, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_MFI, 3775, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__659)) __PYX_ERR(3, 3775, __pyx_L1_error)
-
-  __pyx_tuple__660 = PyTuple_Pack(8, __pyx_n_s_real, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_real_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__660)) __PYX_ERR(3, 3813, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__660);
-  __Pyx_GIVEREF(__pyx_tuple__660);
-  __pyx_codeobj__661 = (PyObject*)__Pyx_PyCode_New(2, 0, 8, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__660, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_MIDPOINT, 3813, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__661)) __PYX_ERR(3, 3813, __pyx_L1_error)
-
-  __pyx_tuple__662 = PyTuple_Pack(10, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__662)) __PYX_ERR(3, 3842, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__662);
-  __Pyx_GIVEREF(__pyx_tuple__662);
-  __pyx_codeobj__663 = (PyObject*)__Pyx_PyCode_New(3, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__662, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_MIDPRICE, 3842, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__663)) __PYX_ERR(3, 3842, __pyx_L1_error)
-
-  __pyx_tuple__664 = PyTuple_Pack(8, __pyx_n_s_real, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_real_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__664)) __PYX_ERR(3, 3874, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__664);
-  __Pyx_GIVEREF(__pyx_tuple__664);
-  __pyx_codeobj__665 = (PyObject*)__Pyx_PyCode_New(2, 0, 8, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__664, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_MIN, 3874, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__665)) __PYX_ERR(3, 3874, __pyx_L1_error)
-
-  __pyx_tuple__666 = PyTuple_Pack(8, __pyx_n_s_real, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_real_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outinteger); if (unlikely(!__pyx_tuple__666)) __PYX_ERR(3, 3903, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__666);
-  __Pyx_GIVEREF(__pyx_tuple__666);
-  __pyx_codeobj__667 = (PyObject*)__Pyx_PyCode_New(2, 0, 8, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__666, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_MININDEX, 3903, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__667)) __PYX_ERR(3, 3903, __pyx_L1_error)
-
-  __pyx_tuple__668 = PyTuple_Pack(9, __pyx_n_s_real, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_real_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outmin, __pyx_n_s_outmax); if (unlikely(!__pyx_tuple__668)) __PYX_ERR(3, 3932, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__668);
-  __Pyx_GIVEREF(__pyx_tuple__668);
-  __pyx_codeobj__669 = (PyObject*)__Pyx_PyCode_New(2, 0, 9, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__668, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_MINMAX, 3932, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__669)) __PYX_ERR(3, 3932, __pyx_L1_error)
-
-  __pyx_tuple__670 = PyTuple_Pack(9, __pyx_n_s_real, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_real_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outminidx, __pyx_n_s_outmaxidx); if (unlikely(!__pyx_tuple__670)) __PYX_ERR(3, 3964, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__670);
-  __Pyx_GIVEREF(__pyx_tuple__670);
-  __pyx_codeobj__671 = (PyObject*)__Pyx_PyCode_New(2, 0, 9, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__670, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_MINMAXINDEX, 3964, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__671)) __PYX_ERR(3, 3964, __pyx_L1_error)
-
-  __pyx_tuple__672 = PyTuple_Pack(12, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_close_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__672)) __PYX_ERR(3, 3996, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__672);
-  __Pyx_GIVEREF(__pyx_tuple__672);
-  __pyx_codeobj__673 = (PyObject*)__Pyx_PyCode_New(4, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__672, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_MINUS_DI, 3996, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__673)) __PYX_ERR(3, 3996, __pyx_L1_error)
-
-  __pyx_tuple__674 = PyTuple_Pack(10, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__674)) __PYX_ERR(3, 4031, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__674);
-  __Pyx_GIVEREF(__pyx_tuple__674);
-  __pyx_codeobj__675 = (PyObject*)__Pyx_PyCode_New(3, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__674, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_MINUS_DM, 4031, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__675)) __PYX_ERR(3, 4031, __pyx_L1_error)
-
-  __pyx_tuple__676 = PyTuple_Pack(8, __pyx_n_s_real, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_real_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__676)) __PYX_ERR(3, 4063, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__676);
-  __Pyx_GIVEREF(__pyx_tuple__676);
-  __pyx_codeobj__677 = (PyObject*)__Pyx_PyCode_New(2, 0, 8, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__676, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_MOM, 4063, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__677)) __PYX_ERR(3, 4063, __pyx_L1_error)
-
-  __pyx_tuple__678 = PyTuple_Pack(9, __pyx_n_s_real0, __pyx_n_s_real1, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_real0_data, __pyx_n_s_real1_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__678)) __PYX_ERR(3, 4092, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__678);
-  __Pyx_GIVEREF(__pyx_tuple__678);
-  __pyx_codeobj__679 = (PyObject*)__Pyx_PyCode_New(2, 0, 9, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__678, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_MULT, 4092, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__679)) __PYX_ERR(3, 4092, __pyx_L1_error)
-
-  __pyx_tuple__680 = PyTuple_Pack(12, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_close_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__680)) __PYX_ERR(3, 4123, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__680);
-  __Pyx_GIVEREF(__pyx_tuple__680);
-  __pyx_codeobj__681 = (PyObject*)__Pyx_PyCode_New(4, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__680, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_NATR, 4123, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__681)) __PYX_ERR(3, 4123, __pyx_L1_error)
-
-  __pyx_tuple__682 = PyTuple_Pack(9, __pyx_n_s_real, __pyx_n_s_volume, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_real_data, __pyx_n_s_volume_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__682)) __PYX_ERR(3, 4158, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__682);
-  __Pyx_GIVEREF(__pyx_tuple__682);
-  __pyx_codeobj__683 = (PyObject*)__Pyx_PyCode_New(2, 0, 9, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__682, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_OBV, 4158, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__683)) __PYX_ERR(3, 4158, __pyx_L1_error)
-
-  __pyx_tuple__684 = PyTuple_Pack(12, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_close_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__684)) __PYX_ERR(3, 4189, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__684);
-  __Pyx_GIVEREF(__pyx_tuple__684);
-  __pyx_codeobj__685 = (PyObject*)__Pyx_PyCode_New(4, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__684, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_PLUS_DI, 4189, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__685)) __PYX_ERR(3, 4189, __pyx_L1_error)
-
-  __pyx_tuple__686 = PyTuple_Pack(10, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__686)) __PYX_ERR(3, 4224, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__686);
-  __Pyx_GIVEREF(__pyx_tuple__686);
-  __pyx_codeobj__687 = (PyObject*)__Pyx_PyCode_New(3, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__686, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_PLUS_DM, 4224, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__687)) __PYX_ERR(3, 4224, __pyx_L1_error)
-
-  __pyx_tuple__688 = PyTuple_Pack(10, __pyx_n_s_real, __pyx_n_s_fastperiod, __pyx_n_s_slowperiod, __pyx_n_s_matype, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_real_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__688)) __PYX_ERR(3, 4256, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__688);
-  __Pyx_GIVEREF(__pyx_tuple__688);
-  __pyx_codeobj__689 = (PyObject*)__Pyx_PyCode_New(4, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__688, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_PPO, 4256, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__689)) __PYX_ERR(3, 4256, __pyx_L1_error)
-
-  __pyx_tuple__690 = PyTuple_Pack(8, __pyx_n_s_real, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_real_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__690)) __PYX_ERR(3, 4287, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__690);
-  __Pyx_GIVEREF(__pyx_tuple__690);
-  __pyx_codeobj__691 = (PyObject*)__Pyx_PyCode_New(2, 0, 8, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__690, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_ROC, 4287, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__691)) __PYX_ERR(3, 4287, __pyx_L1_error)
-
-  __pyx_tuple__692 = PyTuple_Pack(8, __pyx_n_s_real, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_real_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__692)) __PYX_ERR(3, 4316, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__692);
-  __Pyx_GIVEREF(__pyx_tuple__692);
-  __pyx_codeobj__693 = (PyObject*)__Pyx_PyCode_New(2, 0, 8, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__692, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_ROCP, 4316, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__693)) __PYX_ERR(3, 4316, __pyx_L1_error)
-
-  __pyx_tuple__694 = PyTuple_Pack(8, __pyx_n_s_real, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_real_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__694)) __PYX_ERR(3, 4345, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__694);
-  __Pyx_GIVEREF(__pyx_tuple__694);
-  __pyx_codeobj__695 = (PyObject*)__Pyx_PyCode_New(2, 0, 8, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__694, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_ROCR, 4345, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__695)) __PYX_ERR(3, 4345, __pyx_L1_error)
-
-  __pyx_tuple__696 = PyTuple_Pack(8, __pyx_n_s_real, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_real_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__696)) __PYX_ERR(3, 4374, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__696);
-  __Pyx_GIVEREF(__pyx_tuple__696);
-  __pyx_codeobj__697 = (PyObject*)__Pyx_PyCode_New(2, 0, 8, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__696, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_ROCR100, 4374, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__697)) __PYX_ERR(3, 4374, __pyx_L1_error)
-
-  __pyx_tuple__698 = PyTuple_Pack(8, __pyx_n_s_real, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_real_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__698)) __PYX_ERR(3, 4403, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__698);
-  __Pyx_GIVEREF(__pyx_tuple__698);
-  __pyx_codeobj__699 = (PyObject*)__Pyx_PyCode_New(2, 0, 8, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__698, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_RSI, 4403, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__699)) __PYX_ERR(3, 4403, __pyx_L1_error)
-
-  __pyx_tuple__700 = PyTuple_Pack(11, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_acceleration, __pyx_n_s_maximum, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__700)) __PYX_ERR(3, 4432, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__700);
-  __Pyx_GIVEREF(__pyx_tuple__700);
-  __pyx_codeobj__701 = (PyObject*)__Pyx_PyCode_New(4, 0, 11, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__700, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_SAR, 4432, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__701)) __PYX_ERR(3, 4432, __pyx_L1_error)
-
-  __pyx_tuple__702 = PyTuple_Pack(17, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_startvalue, __pyx_n_s_offsetonreverse, __pyx_n_s_accelerationinitlong, __pyx_n_s_accelerationlong, __pyx_n_s_accelerationmaxlong, __pyx_n_s_accelerationinitshort, __pyx_n_s_accelerationshort, __pyx_n_s_accelerationmaxshort, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__702)) __PYX_ERR(3, 4465, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__702);
-  __Pyx_GIVEREF(__pyx_tuple__702);
-  __pyx_codeobj__703 = (PyObject*)__Pyx_PyCode_New(10, 0, 17, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__702, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_SAREXT, 4465, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__703)) __PYX_ERR(3, 4465, __pyx_L1_error)
-
-  __pyx_tuple__704 = PyTuple_Pack(7, __pyx_n_s_real, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_real_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__704)) __PYX_ERR(3, 4504, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__704);
-  __Pyx_GIVEREF(__pyx_tuple__704);
-  __pyx_codeobj__705 = (PyObject*)__Pyx_PyCode_New(1, 0, 7, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__704, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_SIN, 4504, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__705)) __PYX_ERR(3, 4504, __pyx_L1_error)
-
-  __pyx_tuple__706 = PyTuple_Pack(7, __pyx_n_s_real, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_real_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__706)) __PYX_ERR(3, 4531, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__706);
-  __Pyx_GIVEREF(__pyx_tuple__706);
-  __pyx_codeobj__707 = (PyObject*)__Pyx_PyCode_New(1, 0, 7, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__706, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_SINH, 4531, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__707)) __PYX_ERR(3, 4531, __pyx_L1_error)
-
-  __pyx_tuple__708 = PyTuple_Pack(8, __pyx_n_s_real, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_real_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__708)) __PYX_ERR(3, 4558, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__708);
-  __Pyx_GIVEREF(__pyx_tuple__708);
-  __pyx_codeobj__709 = (PyObject*)__Pyx_PyCode_New(2, 0, 8, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__708, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_SMA, 4558, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__709)) __PYX_ERR(3, 4558, __pyx_L1_error)
-
-  __pyx_tuple__710 = PyTuple_Pack(7, __pyx_n_s_real, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_real_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__710)) __PYX_ERR(3, 4587, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__710);
-  __Pyx_GIVEREF(__pyx_tuple__710);
-  __pyx_codeobj__711 = (PyObject*)__Pyx_PyCode_New(1, 0, 7, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__710, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_SQRT, 4587, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__711)) __PYX_ERR(3, 4587, __pyx_L1_error)
-
-  __pyx_tuple__712 = PyTuple_Pack(9, __pyx_n_s_real, __pyx_n_s_timeperiod, __pyx_n_s_nbdev, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_real_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__712)) __PYX_ERR(3, 4614, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__712);
-  __Pyx_GIVEREF(__pyx_tuple__712);
-  __pyx_codeobj__713 = (PyObject*)__Pyx_PyCode_New(3, 0, 9, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__712, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_STDDEV, 4614, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__713)) __PYX_ERR(3, 4614, __pyx_L1_error)
-
-  __pyx_tuple__714 = PyTuple_Pack(17, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_fastk_period, __pyx_n_s_slowk_period, __pyx_n_s_slowk_matype, __pyx_n_s_slowd_period, __pyx_n_s_slowd_matype, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_close_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outslowk, __pyx_n_s_outslowd); if (unlikely(!__pyx_tuple__714)) __PYX_ERR(3, 4644, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__714);
-  __Pyx_GIVEREF(__pyx_tuple__714);
-  __pyx_codeobj__715 = (PyObject*)__Pyx_PyCode_New(8, 0, 17, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__714, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_STOCH, 4644, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__715)) __PYX_ERR(3, 4644, __pyx_L1_error)
-
-  __pyx_tuple__716 = PyTuple_Pack(15, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_fastk_period, __pyx_n_s_fastd_period, __pyx_n_s_fastd_matype, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_close_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outfastk, __pyx_n_s_outfastd); if (unlikely(!__pyx_tuple__716)) __PYX_ERR(3, 4686, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__716);
-  __Pyx_GIVEREF(__pyx_tuple__716);
-  __pyx_codeobj__717 = (PyObject*)__Pyx_PyCode_New(6, 0, 15, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__716, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_STOCHF, 4686, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__717)) __PYX_ERR(3, 4686, __pyx_L1_error)
-
-  __pyx_tuple__718 = PyTuple_Pack(12, __pyx_n_s_real, __pyx_n_s_timeperiod, __pyx_n_s_fastk_period, __pyx_n_s_fastd_period, __pyx_n_s_fastd_matype, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_real_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outfastk, __pyx_n_s_outfastd); if (unlikely(!__pyx_tuple__718)) __PYX_ERR(3, 4726, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__718);
-  __Pyx_GIVEREF(__pyx_tuple__718);
-  __pyx_codeobj__719 = (PyObject*)__Pyx_PyCode_New(5, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__718, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_STOCHRSI, 4726, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__719)) __PYX_ERR(3, 4726, __pyx_L1_error)
-
-  __pyx_tuple__720 = PyTuple_Pack(9, __pyx_n_s_real0, __pyx_n_s_real1, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_real0_data, __pyx_n_s_real1_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__720)) __PYX_ERR(3, 4761, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__720);
-  __Pyx_GIVEREF(__pyx_tuple__720);
-  __pyx_codeobj__721 = (PyObject*)__Pyx_PyCode_New(2, 0, 9, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__720, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_SUB, 4761, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__721)) __PYX_ERR(3, 4761, __pyx_L1_error)
-
-  __pyx_tuple__722 = PyTuple_Pack(8, __pyx_n_s_real, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_real_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__722)) __PYX_ERR(3, 4792, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__722);
-  __Pyx_GIVEREF(__pyx_tuple__722);
-  __pyx_codeobj__723 = (PyObject*)__Pyx_PyCode_New(2, 0, 8, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__722, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_SUM, 4792, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__723)) __PYX_ERR(3, 4792, __pyx_L1_error)
-
-  __pyx_tuple__724 = PyTuple_Pack(9, __pyx_n_s_real, __pyx_n_s_timeperiod, __pyx_n_s_vfactor, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_real_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__724)) __PYX_ERR(3, 4821, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__724);
-  __Pyx_GIVEREF(__pyx_tuple__724);
-  __pyx_codeobj__725 = (PyObject*)__Pyx_PyCode_New(3, 0, 9, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__724, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_T3, 4821, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__725)) __PYX_ERR(3, 4821, __pyx_L1_error)
-
-  __pyx_tuple__726 = PyTuple_Pack(7, __pyx_n_s_real, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_real_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__726)) __PYX_ERR(3, 4851, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__726);
-  __Pyx_GIVEREF(__pyx_tuple__726);
-  __pyx_codeobj__727 = (PyObject*)__Pyx_PyCode_New(1, 0, 7, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__726, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_TAN, 4851, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__727)) __PYX_ERR(3, 4851, __pyx_L1_error)
-
-  __pyx_tuple__728 = PyTuple_Pack(7, __pyx_n_s_real, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_real_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__728)) __PYX_ERR(3, 4878, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__728);
-  __Pyx_GIVEREF(__pyx_tuple__728);
-  __pyx_codeobj__729 = (PyObject*)__Pyx_PyCode_New(1, 0, 7, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__728, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_TANH, 4878, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__729)) __PYX_ERR(3, 4878, __pyx_L1_error)
-
-  __pyx_tuple__730 = PyTuple_Pack(8, __pyx_n_s_real, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_real_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__730)) __PYX_ERR(3, 4905, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__730);
-  __Pyx_GIVEREF(__pyx_tuple__730);
-  __pyx_codeobj__731 = (PyObject*)__Pyx_PyCode_New(2, 0, 8, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__730, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_TEMA, 4905, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__731)) __PYX_ERR(3, 4905, __pyx_L1_error)
-
-  __pyx_tuple__732 = PyTuple_Pack(11, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_close_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__732)) __PYX_ERR(3, 4934, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__732);
-  __Pyx_GIVEREF(__pyx_tuple__732);
-  __pyx_codeobj__733 = (PyObject*)__Pyx_PyCode_New(3, 0, 11, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__732, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_TRANGE, 4934, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__733)) __PYX_ERR(3, 4934, __pyx_L1_error)
-
-  __pyx_tuple__734 = PyTuple_Pack(8, __pyx_n_s_real, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_real_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__734)) __PYX_ERR(3, 4967, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__734);
-  __Pyx_GIVEREF(__pyx_tuple__734);
-  __pyx_codeobj__735 = (PyObject*)__Pyx_PyCode_New(2, 0, 8, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__734, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_TRIMA, 4967, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__735)) __PYX_ERR(3, 4967, __pyx_L1_error)
-
-  __pyx_tuple__736 = PyTuple_Pack(8, __pyx_n_s_real, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_real_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__736)) __PYX_ERR(3, 4996, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__736);
-  __Pyx_GIVEREF(__pyx_tuple__736);
-  __pyx_codeobj__737 = (PyObject*)__Pyx_PyCode_New(2, 0, 8, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__736, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_TRIX, 4996, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__737)) __PYX_ERR(3, 4996, __pyx_L1_error)
-
-  __pyx_tuple__738 = PyTuple_Pack(8, __pyx_n_s_real, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_real_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__738)) __PYX_ERR(3, 5025, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__738);
-  __Pyx_GIVEREF(__pyx_tuple__738);
-  __pyx_codeobj__739 = (PyObject*)__Pyx_PyCode_New(2, 0, 8, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__738, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_TSF, 5025, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__739)) __PYX_ERR(3, 5025, __pyx_L1_error)
-
-  __pyx_tuple__740 = PyTuple_Pack(11, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_close_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__740)) __PYX_ERR(3, 5054, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__740);
-  __Pyx_GIVEREF(__pyx_tuple__740);
-  __pyx_codeobj__741 = (PyObject*)__Pyx_PyCode_New(3, 0, 11, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__740, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_TYPPRICE, 5054, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__741)) __PYX_ERR(3, 5054, __pyx_L1_error)
-
-  __pyx_tuple__742 = PyTuple_Pack(14, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_timeperiod1, __pyx_n_s_timeperiod2, __pyx_n_s_timeperiod3, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_close_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__742)) __PYX_ERR(3, 5087, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__742);
-  __Pyx_GIVEREF(__pyx_tuple__742);
-  __pyx_codeobj__743 = (PyObject*)__Pyx_PyCode_New(6, 0, 14, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__742, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_ULTOSC, 5087, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__743)) __PYX_ERR(3, 5087, __pyx_L1_error)
-
-  __pyx_tuple__744 = PyTuple_Pack(9, __pyx_n_s_real, __pyx_n_s_timeperiod, __pyx_n_s_nbdev, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_real_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__744)) __PYX_ERR(3, 5124, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__744);
-  __Pyx_GIVEREF(__pyx_tuple__744);
-  __pyx_codeobj__745 = (PyObject*)__Pyx_PyCode_New(3, 0, 9, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__744, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_VAR, 5124, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__745)) __PYX_ERR(3, 5124, __pyx_L1_error)
-
-  __pyx_tuple__746 = PyTuple_Pack(11, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_close_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__746)) __PYX_ERR(3, 5154, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__746);
-  __Pyx_GIVEREF(__pyx_tuple__746);
-  __pyx_codeobj__747 = (PyObject*)__Pyx_PyCode_New(3, 0, 11, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__746, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_WCLPRICE, 5154, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__747)) __PYX_ERR(3, 5154, __pyx_L1_error)
-
-  __pyx_tuple__748 = PyTuple_Pack(12, __pyx_n_s_high, __pyx_n_s_low, __pyx_n_s_close, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_high_data, __pyx_n_s_low_data, __pyx_n_s_close_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__748)) __PYX_ERR(3, 5187, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__748);
-  __Pyx_GIVEREF(__pyx_tuple__748);
-  __pyx_codeobj__749 = (PyObject*)__Pyx_PyCode_New(4, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__748, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_WILLR, 5187, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__749)) __PYX_ERR(3, 5187, __pyx_L1_error)
-
-  __pyx_tuple__750 = PyTuple_Pack(8, __pyx_n_s_real, __pyx_n_s_timeperiod, __pyx_n_s_length, __pyx_n_s_retCode, __pyx_n_s_real_data, __pyx_n_s_outbegidx, __pyx_n_s_outnbelement, __pyx_n_s_outreal); if (unlikely(!__pyx_tuple__750)) __PYX_ERR(3, 5222, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__750);
-  __Pyx_GIVEREF(__pyx_tuple__750);
-  __pyx_codeobj__751 = (PyObject*)__Pyx_PyCode_New(2, 0, 8, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__750, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_talib__stream_pxi, __pyx_n_s_stream_WMA, 5222, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__751)) __PYX_ERR(3, 5222, __pyx_L1_error)
-  __Pyx_RefNannyFinishContext();
-  return 0;
-  __pyx_L1_error:;
-  __Pyx_RefNannyFinishContext();
-  return -1;
-}
+  __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low));
 
-static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) {
-  __pyx_umethod_PyDict_Type_keys.type = (PyObject*)&PyDict_Type;
-  if (__Pyx_InitStrings(__pyx_string_tab) < 0) __PYX_ERR(5, 1, __pyx_L1_error);
-  __pyx_int_0 = PyInt_FromLong(0); if (unlikely(!__pyx_int_0)) __PYX_ERR(5, 1, __pyx_L1_error)
-  __pyx_int_1 = PyInt_FromLong(1); if (unlikely(!__pyx_int_1)) __PYX_ERR(5, 1, __pyx_L1_error)
-  __pyx_int_2 = PyInt_FromLong(2); if (unlikely(!__pyx_int_2)) __PYX_ERR(5, 1, __pyx_L1_error)
-  __pyx_int_3 = PyInt_FromLong(3); if (unlikely(!__pyx_int_3)) __PYX_ERR(5, 1, __pyx_L1_error)
-  __pyx_int_4 = PyInt_FromLong(4); if (unlikely(!__pyx_int_4)) __PYX_ERR(5, 1, __pyx_L1_error)
-  __pyx_int_8 = PyInt_FromLong(8); if (unlikely(!__pyx_int_8)) __PYX_ERR(5, 1, __pyx_L1_error)
-  __pyx_int_9 = PyInt_FromLong(9); if (unlikely(!__pyx_int_9)) __PYX_ERR(5, 1, __pyx_L1_error)
-  __pyx_int_12 = PyInt_FromLong(12); if (unlikely(!__pyx_int_12)) __PYX_ERR(5, 1, __pyx_L1_error)
-  __pyx_int_16 = PyInt_FromLong(16); if (unlikely(!__pyx_int_16)) __PYX_ERR(5, 1, __pyx_L1_error)
-  __pyx_int_32 = PyInt_FromLong(32); if (unlikely(!__pyx_int_32)) __PYX_ERR(5, 1, __pyx_L1_error)
-  __pyx_int_64 = PyInt_FromLong(64); if (unlikely(!__pyx_int_64)) __PYX_ERR(5, 1, __pyx_L1_error)
-  __pyx_int_128 = PyInt_FromLong(128); if (unlikely(!__pyx_int_128)) __PYX_ERR(5, 1, __pyx_L1_error)
-  __pyx_int_256 = PyInt_FromLong(256); if (unlikely(!__pyx_int_256)) __PYX_ERR(5, 1, __pyx_L1_error)
-  __pyx_int_512 = PyInt_FromLong(512); if (unlikely(!__pyx_int_512)) __PYX_ERR(5, 1, __pyx_L1_error)
-  __pyx_int_1024 = PyInt_FromLong(1024); if (unlikely(!__pyx_int_1024)) __PYX_ERR(5, 1, __pyx_L1_error)
-  __pyx_int_2048 = PyInt_FromLong(2048); if (unlikely(!__pyx_int_2048)) __PYX_ERR(5, 1, __pyx_L1_error)
-  __pyx_int_4096 = PyInt_FromLong(4096); if (unlikely(!__pyx_int_4096)) __PYX_ERR(5, 1, __pyx_L1_error)
-  __pyx_int_16777216 = PyInt_FromLong(16777216L); if (unlikely(!__pyx_int_16777216)) __PYX_ERR(5, 1, __pyx_L1_error)
-  __pyx_int_67108864 = PyInt_FromLong(67108864L); if (unlikely(!__pyx_int_67108864)) __PYX_ERR(5, 1, __pyx_L1_error)
-  __pyx_int_134217728 = PyInt_FromLong(134217728L); if (unlikely(!__pyx_int_134217728)) __PYX_ERR(5, 1, __pyx_L1_error)
-  __pyx_int_268435456 = PyInt_FromLong(268435456L); if (unlikely(!__pyx_int_268435456)) __PYX_ERR(5, 1, __pyx_L1_error)
-  __pyx_int_neg_1 = PyInt_FromLong(-1); if (unlikely(!__pyx_int_neg_1)) __PYX_ERR(5, 1, __pyx_L1_error)
-  return 0;
-  __pyx_L1_error:;
-  return -1;
-}
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4817, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
 
-static CYTHON_SMALL_CODE int __Pyx_modinit_global_init_code(void); /*proto*/
-static CYTHON_SMALL_CODE int __Pyx_modinit_variable_export_code(void); /*proto*/
-static CYTHON_SMALL_CODE int __Pyx_modinit_function_export_code(void); /*proto*/
-static CYTHON_SMALL_CODE int __Pyx_modinit_type_init_code(void); /*proto*/
-static CYTHON_SMALL_CODE int __Pyx_modinit_type_import_code(void); /*proto*/
-static CYTHON_SMALL_CODE int __Pyx_modinit_variable_import_code(void); /*proto*/
-static CYTHON_SMALL_CODE int __Pyx_modinit_function_import_code(void); /*proto*/
+  __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close));
 
-static int __Pyx_modinit_global_init_code(void) {
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__Pyx_modinit_global_init_code", 0);
-  /*--- Global init code ---*/
-  __Pyx_RefNannyFinishContext();
-  return 0;
-}
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 4819, __pyx_L1_error)
+  __pyx_v_length = __pyx_t_2;
 
-static int __Pyx_modinit_variable_export_code(void) {
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__Pyx_modinit_variable_export_code", 0);
-  /*--- Variable export code ---*/
-  __Pyx_RefNannyFinishContext();
-  return 0;
-}
+  __pyx_v_outfastk = __pyx_v_5talib_7_ta_lib_NaN;
 
-static int __Pyx_modinit_function_export_code(void) {
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__Pyx_modinit_function_export_code", 0);
-  /*--- Function export code ---*/
-  __Pyx_RefNannyFinishContext();
-  return 0;
-}
+  __pyx_v_outfastd = __pyx_v_5talib_7_ta_lib_NaN;
 
-static int __Pyx_modinit_type_init_code(void) {
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__Pyx_modinit_type_init_code", 0);
-  /*--- Type init code ---*/
-  __Pyx_RefNannyFinishContext();
-  return 0;
-}
+  __pyx_v_retCode = TA_STOCHF((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, __pyx_v_fastk_period, __pyx_v_fastd_period, __pyx_v_fastd_matype, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outfastk), (&__pyx_v_outfastd));
 
-static int __Pyx_modinit_type_import_code(void) {
-  __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
-  __Pyx_RefNannySetupContext("__Pyx_modinit_type_import_code", 0);
-  /*--- Type import code ---*/
-  __pyx_t_1 = PyImport_ImportModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 9, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_STOCHF, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4823, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_ptype_7cpython_4type_type = __Pyx_ImportType(__pyx_t_1, __Pyx_BUILTIN_MODULE_NAME, "type", 
-  #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000
-  sizeof(PyTypeObject),
-  #else
-  sizeof(PyHeapTypeObject),
-  #endif
-  __Pyx_ImportType_CheckSize_Warn);
-   if (!__pyx_ptype_7cpython_4type_type) __PYX_ERR(6, 9, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_1 = PyImport_ImportModule("numpy"); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 206, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_ptype_5numpy_dtype = __Pyx_ImportType(__pyx_t_1, "numpy", "dtype", sizeof(PyArray_Descr), __Pyx_ImportType_CheckSize_Ignore);
-   if (!__pyx_ptype_5numpy_dtype) __PYX_ERR(4, 206, __pyx_L1_error)
-  __pyx_ptype_5numpy_flatiter = __Pyx_ImportType(__pyx_t_1, "numpy", "flatiter", sizeof(PyArrayIterObject), __Pyx_ImportType_CheckSize_Warn);
-   if (!__pyx_ptype_5numpy_flatiter) __PYX_ERR(4, 229, __pyx_L1_error)
-  __pyx_ptype_5numpy_broadcast = __Pyx_ImportType(__pyx_t_1, "numpy", "broadcast", sizeof(PyArrayMultiIterObject), __Pyx_ImportType_CheckSize_Warn);
-   if (!__pyx_ptype_5numpy_broadcast) __PYX_ERR(4, 233, __pyx_L1_error)
-  __pyx_ptype_5numpy_ndarray = __Pyx_ImportType(__pyx_t_1, "numpy", "ndarray", sizeof(PyArrayObject), __Pyx_ImportType_CheckSize_Ignore);
-   if (!__pyx_ptype_5numpy_ndarray) __PYX_ERR(4, 242, __pyx_L1_error)
-  __pyx_ptype_5numpy_ufunc = __Pyx_ImportType(__pyx_t_1, "numpy", "ufunc", sizeof(PyUFuncObject), __Pyx_ImportType_CheckSize_Warn);
-   if (!__pyx_ptype_5numpy_ufunc) __PYX_ERR(4, 918, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __Pyx_RefNannyFinishContext();
-  return 0;
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_RefNannyFinishContext();
-  return -1;
-}
 
-static int __Pyx_modinit_variable_import_code(void) {
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__Pyx_modinit_variable_import_code", 0);
-  /*--- Variable import code ---*/
-  __Pyx_RefNannyFinishContext();
-  return 0;
-}
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outfastk); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4824, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_3 = PyFloat_FromDouble(__pyx_v_outfastd); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 4824, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 4824, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_GIVEREF(__pyx_t_1);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1) != (0)) __PYX_ERR(5, 4824, __pyx_L1_error);
+  __Pyx_GIVEREF(__pyx_t_3);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_3) != (0)) __PYX_ERR(5, 4824, __pyx_L1_error);
+  __pyx_t_1 = 0;
+  __pyx_t_3 = 0;
+  __pyx_r = __pyx_t_4;
+  __pyx_t_4 = 0;
+  goto __pyx_L0;
 
-static int __Pyx_modinit_function_import_code(void) {
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__Pyx_modinit_function_import_code", 0);
-  /*--- Function import code ---*/
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_AddTraceback("talib._ta_lib.stream_STOCHF", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_high);
+  __Pyx_XDECREF((PyObject *)__pyx_v_low);
+  __Pyx_XDECREF((PyObject *)__pyx_v_close);
+  __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
-  return 0;
+  return __pyx_r;
 }
 
 
-#if PY_MAJOR_VERSION < 3
-#ifdef CYTHON_NO_PYINIT_EXPORT
-#define __Pyx_PyMODINIT_FUNC void
+/* Python wrapper */
+static PyObject *__pyx_pw_5talib_7_ta_lib_653stream_STOCHRSI(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
 #else
-#define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC
+PyObject *__pyx_args, PyObject *__pyx_kwds
 #endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_652stream_STOCHRSI, "stream_STOCHRSI(ndarray real, int timeperiod=-0x80000000, int fastk_period=-0x80000000, int fastd_period=-0x80000000, int fastd_matype=0)\n\nSTOCHRSI(real[, timeperiod=?, fastk_period=?, fastd_period=?, fastd_matype=?])\n\nStochastic Relative Strength Index (Momentum Indicators)\n\nInputs:\n    real: (any ndarray)\nParameters:\n    timeperiod: 14\n    fastk_period: 5\n    fastd_period: 3\n    fastd_matype: 0\nOutputs:\n    fastk\n    fastd");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_653stream_STOCHRSI = {"stream_STOCHRSI", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_653stream_STOCHRSI, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_652stream_STOCHRSI};
+static PyObject *__pyx_pw_5talib_7_ta_lib_653stream_STOCHRSI(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
 #else
-#ifdef CYTHON_NO_PYINIT_EXPORT
-#define __Pyx_PyMODINIT_FUNC PyObject *
-#else
-#define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC
-#endif
+PyObject *__pyx_args, PyObject *__pyx_kwds
 #endif
-
-
-#if PY_MAJOR_VERSION < 3
-__Pyx_PyMODINIT_FUNC init_ta_lib(void) CYTHON_SMALL_CODE; /*proto*/
-__Pyx_PyMODINIT_FUNC init_ta_lib(void)
-#else
-__Pyx_PyMODINIT_FUNC PyInit__ta_lib(void) CYTHON_SMALL_CODE; /*proto*/
-__Pyx_PyMODINIT_FUNC PyInit__ta_lib(void)
-#if CYTHON_PEP489_MULTI_PHASE_INIT
-{
-  return PyModuleDef_Init(&__pyx_moduledef);
-}
-static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) {
-    #if PY_VERSION_HEX >= 0x030700A1
-    static PY_INT64_T main_interpreter_id = -1;
-    PY_INT64_T current_id = PyInterpreterState_GetID(PyThreadState_Get()->interp);
-    if (main_interpreter_id == -1) {
-        main_interpreter_id = current_id;
-        return (unlikely(current_id == -1)) ? -1 : 0;
-    } else if (unlikely(main_interpreter_id != current_id))
-    #else
-    static PyInterpreterState *main_interpreter = NULL;
-    PyInterpreterState *current_interpreter = PyThreadState_Get()->interp;
-    if (!main_interpreter) {
-        main_interpreter = current_interpreter;
-    } else if (unlikely(main_interpreter != current_interpreter))
-    #endif
-    {
-        PyErr_SetString(
-            PyExc_ImportError,
-            "Interpreter change detected - this module can only be loaded into one interpreter per process.");
-        return -1;
-    }
-    return 0;
-}
-static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none) {
-    PyObject *value = PyObject_GetAttrString(spec, from_name);
-    int result = 0;
-    if (likely(value)) {
-        if (allow_none || value != Py_None) {
-            result = PyDict_SetItemString(moddict, to_name, value);
-        }
-        Py_DECREF(value);
-    } else if (PyErr_ExceptionMatches(PyExc_AttributeError)) {
-        PyErr_Clear();
-    } else {
-        result = -1;
-    }
-    return result;
-}
-static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, CYTHON_UNUSED PyModuleDef *def) {
-    PyObject *module = NULL, *moddict, *modname;
-    if (__Pyx_check_single_interpreter())
-        return NULL;
-    if (__pyx_m)
-        return __Pyx_NewRef(__pyx_m);
-    modname = PyObject_GetAttrString(spec, "name");
-    if (unlikely(!modname)) goto bad;
-    module = PyModule_NewObject(modname);
-    Py_DECREF(modname);
-    if (unlikely(!module)) goto bad;
-    moddict = PyModule_GetDict(module);
-    if (unlikely(!moddict)) goto bad;
-    if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "loader", "__loader__", 1) < 0)) goto bad;
-    if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "origin", "__file__", 1) < 0)) goto bad;
-    if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "parent", "__package__", 1) < 0)) goto bad;
-    if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "submodule_search_locations", "__path__", 0) < 0)) goto bad;
-    return module;
-bad:
-    Py_XDECREF(module);
-    return NULL;
-}
-
-
-static CYTHON_SMALL_CODE int __pyx_pymod_exec__ta_lib(PyObject *__pyx_pyinit_module)
-#endif
-#endif
-{
-  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;
-  PyObject *__pyx_t_6 = NULL;
-  PyObject *__pyx_t_7 = NULL;
-  PyObject *__pyx_t_8 = NULL;
-  PyObject *__pyx_t_9 = NULL;
-  PyObject *__pyx_t_10 = NULL;
-  PyObject *__pyx_t_11 = NULL;
-  PyObject *__pyx_t_12 = NULL;
-  PyObject *__pyx_t_13 = NULL;
-  PyObject *(*__pyx_t_14)(PyObject *);
-  Py_ssize_t __pyx_t_15;
-  PyObject *__pyx_t_16 = NULL;
-  PyObject *__pyx_t_17 = NULL;
-  PyObject *__pyx_t_18 = NULL;
-  double __pyx_t_19;
-  int __pyx_t_20;
-  PyObject *__pyx_t_21 = NULL;
-  PyObject *__pyx_t_22 = NULL;
-  PyObject *__pyx_t_23 = NULL;
-  int __pyx_t_24;
-  __Pyx_RefNannyDeclarations
-  #if CYTHON_PEP489_MULTI_PHASE_INIT
-  if (__pyx_m) {
-    if (__pyx_m == __pyx_pyinit_module) return 0;
-    PyErr_SetString(PyExc_RuntimeError, "Module '_ta_lib' has already been imported. Re-initialisation is not supported.");
-    return -1;
-  }
-  #elif PY_MAJOR_VERSION >= 3
-  if (__pyx_m) return __Pyx_NewRef(__pyx_m);
-  #endif
-  #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("__Pyx_PyMODINIT_FUNC PyInit__ta_lib(void)", 0);
-  if (__Pyx_check_binary_version() < 0) __PYX_ERR(5, 1, __pyx_L1_error)
-  #ifdef __Pxy_PyFrame_Initialize_Offsets
-  __Pxy_PyFrame_Initialize_Offsets();
-  #endif
-  __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) __PYX_ERR(5, 1, __pyx_L1_error)
-  __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(5, 1, __pyx_L1_error)
-  __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(5, 1, __pyx_L1_error)
-  #ifdef __Pyx_CyFunction_USED
-  if (__pyx_CyFunction_init() < 0) __PYX_ERR(5, 1, __pyx_L1_error)
-  #endif
-  #ifdef __Pyx_FusedFunction_USED
-  if (__pyx_FusedFunction_init() < 0) __PYX_ERR(5, 1, __pyx_L1_error)
-  #endif
-  #ifdef __Pyx_Coroutine_USED
-  if (__pyx_Coroutine_init() < 0) __PYX_ERR(5, 1, __pyx_L1_error)
-  #endif
-  #ifdef __Pyx_Generator_USED
-  if (__pyx_Generator_init() < 0) __PYX_ERR(5, 1, __pyx_L1_error)
-  #endif
-  #ifdef __Pyx_AsyncGen_USED
-  if (__pyx_AsyncGen_init() < 0) __PYX_ERR(5, 1, __pyx_L1_error)
-  #endif
-  #ifdef __Pyx_StopAsyncIteration_USED
-  if (__pyx_StopAsyncIteration_init() < 0) __PYX_ERR(5, 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
+) {
+  PyArrayObject *__pyx_v_real = 0;
+  int __pyx_v_timeperiod;
+  int __pyx_v_fastk_period;
+  int __pyx_v_fastd_period;
+  int __pyx_v_fastd_matype;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
   #endif
-  /*--- Module creation code ---*/
-  #if CYTHON_PEP489_MULTI_PHASE_INIT
-  __pyx_m = __pyx_pyinit_module;
-  Py_INCREF(__pyx_m);
-  #else
-  #if PY_MAJOR_VERSION < 3
-  __pyx_m = Py_InitModule4("_ta_lib", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m);
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[5] = {0,0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("stream_STOCHRSI (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
   #else
-  __pyx_m = PyModule_Create(&__pyx_moduledef);
-  #endif
-  if (unlikely(!__pyx_m)) __PYX_ERR(5, 1, __pyx_L1_error)
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
   #endif
-  __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(5, 1, __pyx_L1_error)
-  Py_INCREF(__pyx_d);
-  __pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(5, 1, __pyx_L1_error)
-  __pyx_cython_runtime = PyImport_AddModule((char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(5, 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(5, 1, __pyx_L1_error);
-  /*--- Initialize various global constants etc. ---*/
-  if (__Pyx_InitGlobals() < 0) __PYX_ERR(5, 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(5, 1, __pyx_L1_error)
-  #endif
-  if (__pyx_module_is_main_talib___ta_lib) {
-    if (PyObject_SetAttr(__pyx_m, __pyx_n_s_name_2, __pyx_n_s_main) < 0) __PYX_ERR(5, 1, __pyx_L1_error)
-  }
-  #if PY_MAJOR_VERSION >= 3
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(5, 1, __pyx_L1_error)
-    if (!PyDict_GetItemString(modules, "talib._ta_lib")) {
-      if (unlikely(PyDict_SetItemString(modules, "talib._ta_lib", __pyx_m) < 0)) __PYX_ERR(5, 1, __pyx_L1_error)
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,&__pyx_mstate_global->__pyx_n_u_fastk_period,&__pyx_mstate_global->__pyx_n_u_fastd_period,&__pyx_mstate_global->__pyx_n_u_fastd_matype,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 4826, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  5:
+        values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(5, 4826, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 4826, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 4826, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4826, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4826, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_STOCHRSI", 0) < (0)) __PYX_ERR(5, 4826, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_STOCHRSI", 0, 1, 5, i); __PYX_ERR(5, 4826, __pyx_L3_error) }
+      }
+    } else {
+      switch (__pyx_nargs) {
+        case  5:
+        values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(5, 4826, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 4826, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 4826, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4826, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4826, __pyx_L3_error)
+        break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+    }
+    __pyx_v_real = ((PyArrayObject *)values[0]);
+    if (values[1]) {
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 4828, __pyx_L3_error)
+    } else {
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
+    }
+    if (values[2]) {
+      __pyx_v_fastk_period = __Pyx_PyLong_As_int(values[2]); if (unlikely((__pyx_v_fastk_period == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 4828, __pyx_L3_error)
+    } else {
+      __pyx_v_fastk_period = ((int)((int)-2147483648));
+    }
+    if (values[3]) {
+      __pyx_v_fastd_period = __Pyx_PyLong_As_int(values[3]); if (unlikely((__pyx_v_fastd_period == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 4828, __pyx_L3_error)
+    } else {
+      __pyx_v_fastd_period = ((int)((int)-2147483648));
+    }
+    if (values[4]) {
+      __pyx_v_fastd_matype = __Pyx_PyLong_As_int(values[4]); if (unlikely((__pyx_v_fastd_matype == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 4828, __pyx_L3_error)
+    } else {
+      __pyx_v_fastd_matype = ((int)((int)0));
     }
   }
-  #endif
-  /*--- Builtin init code ---*/
-  if (__Pyx_InitCachedBuiltins() < 0) __PYX_ERR(5, 1, __pyx_L1_error)
-  /*--- Constants init code ---*/
-  if (__Pyx_InitCachedConstants() < 0) __PYX_ERR(5, 1, __pyx_L1_error)
-  /*--- Global type/function init code ---*/
-  (void)__Pyx_modinit_global_init_code();
-  (void)__Pyx_modinit_variable_export_code();
-  (void)__Pyx_modinit_function_export_code();
-  (void)__Pyx_modinit_type_init_code();
-  if (unlikely(__Pyx_modinit_type_import_code() != 0)) goto __pyx_L1_error;
-  (void)__Pyx_modinit_variable_import_code();
-  (void)__Pyx_modinit_function_import_code();
-  /*--- Execution code ---*/
-  #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED)
-  if (__Pyx_patch_abc() < 0) __PYX_ERR(5, 1, __pyx_L1_error)
-  #endif
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("stream_STOCHRSI", 0, 1, 5, __pyx_nargs); __PYX_ERR(5, 4826, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_STOCHRSI", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 4828, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_652stream_STOCHRSI(__pyx_self, __pyx_v_real, __pyx_v_timeperiod, __pyx_v_fastk_period, __pyx_v_fastd_period, __pyx_v_fastd_matype);
 
-  __pyx_t_1 = __Pyx_PyBytes_FromString(TA_GetVersionString()); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_ta_version, __pyx_t_1) < 0) __PYX_ERR(0, 4, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
+  __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_5talib_7_ta_lib_652stream_STOCHRSI(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod, int __pyx_v_fastk_period, int __pyx_v_fastd_period, int __pyx_v_fastd_matype) {
+  npy_intp __pyx_v_length;
+  TA_RetCode __pyx_v_retCode;
+  double *__pyx_v_real_data;
+  int __pyx_v_outbegidx;
+  int __pyx_v_outnbelement;
+  double __pyx_v_outfastk;
+  double __pyx_v_outfastd;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_STOCHRSI", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_3_ta_initialize, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 50, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4852, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_ta_initialize, __pyx_t_1) < 0) __PYX_ERR(0, 50, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
+
+  __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real));
+
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
+
+  __pyx_v_outfastk = __pyx_v_5talib_7_ta_lib_NaN;
+
+  __pyx_v_outfastd = __pyx_v_5talib_7_ta_lib_NaN;
+
+  __pyx_v_retCode = TA_STOCHRSI((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, __pyx_v_fastk_period, __pyx_v_fastd_period, __pyx_v_fastd_matype, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outfastk), (&__pyx_v_outfastd));
 
-  __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_5_ta_shutdown, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 55, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_STOCHRSI, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4858, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_ta_shutdown, __pyx_t_1) < 0) __PYX_ERR(0, 55, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
-  __pyx_t_1 = __Pyx_CalculateMetaclass(NULL, __pyx_tuple__23); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 60, __pyx_L1_error)
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outfastk); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4859, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = __Pyx_Py3MetaclassPrepare(__pyx_t_1, __pyx_tuple__23, __pyx_n_s_MA_Type, __pyx_n_s_MA_Type, (PyObject *) NULL, __pyx_n_s_talib__ta_lib, (PyObject *) NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 60, __pyx_L1_error)
+  __pyx_t_2 = PyFloat_FromDouble(__pyx_v_outfastd); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 4859, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-
-  __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_range, __pyx_tuple__24, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 61, __pyx_L1_error)
+  __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 4859, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
-  if ((likely(PyTuple_CheckExact(__pyx_t_3))) || (PyList_CheckExact(__pyx_t_3))) {
-    PyObject* sequence = __pyx_t_3;
-    Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
-    if (unlikely(size != 9)) {
-      if (size > 9) __Pyx_RaiseTooManyValuesError(9);
-      else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
-      __PYX_ERR(0, 61, __pyx_L1_error)
-    }
-    #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-    if (likely(PyTuple_CheckExact(sequence))) {
-      __pyx_t_4 = PyTuple_GET_ITEM(sequence, 0); 
-      __pyx_t_5 = PyTuple_GET_ITEM(sequence, 1); 
-      __pyx_t_6 = PyTuple_GET_ITEM(sequence, 2); 
-      __pyx_t_7 = PyTuple_GET_ITEM(sequence, 3); 
-      __pyx_t_8 = PyTuple_GET_ITEM(sequence, 4); 
-      __pyx_t_9 = PyTuple_GET_ITEM(sequence, 5); 
-      __pyx_t_10 = PyTuple_GET_ITEM(sequence, 6); 
-      __pyx_t_11 = PyTuple_GET_ITEM(sequence, 7); 
-      __pyx_t_12 = PyTuple_GET_ITEM(sequence, 8); 
-    } else {
-      __pyx_t_4 = PyList_GET_ITEM(sequence, 0); 
-      __pyx_t_5 = PyList_GET_ITEM(sequence, 1); 
-      __pyx_t_6 = PyList_GET_ITEM(sequence, 2); 
-      __pyx_t_7 = PyList_GET_ITEM(sequence, 3); 
-      __pyx_t_8 = PyList_GET_ITEM(sequence, 4); 
-      __pyx_t_9 = PyList_GET_ITEM(sequence, 5); 
-      __pyx_t_10 = PyList_GET_ITEM(sequence, 6); 
-      __pyx_t_11 = PyList_GET_ITEM(sequence, 7); 
-      __pyx_t_12 = PyList_GET_ITEM(sequence, 8); 
-    }
-    __Pyx_INCREF(__pyx_t_4);
-    __Pyx_INCREF(__pyx_t_5);
-    __Pyx_INCREF(__pyx_t_6);
-    __Pyx_INCREF(__pyx_t_7);
-    __Pyx_INCREF(__pyx_t_8);
-    __Pyx_INCREF(__pyx_t_9);
-    __Pyx_INCREF(__pyx_t_10);
-    __Pyx_INCREF(__pyx_t_11);
-    __Pyx_INCREF(__pyx_t_12);
-    #else
-    {
-      Py_ssize_t i;
-      PyObject** temps[9] = {&__pyx_t_4,&__pyx_t_5,&__pyx_t_6,&__pyx_t_7,&__pyx_t_8,&__pyx_t_9,&__pyx_t_10,&__pyx_t_11,&__pyx_t_12};
-      for (i=0; i < 9; i++) {
-        PyObject* item = PySequence_ITEM(sequence, i); if (unlikely(!item)) __PYX_ERR(0, 61, __pyx_L1_error)
-        __Pyx_GOTREF(item);
-        *(temps[i]) = item;
+  __Pyx_GIVEREF(__pyx_t_1);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1) != (0)) __PYX_ERR(5, 4859, __pyx_L1_error);
+  __Pyx_GIVEREF(__pyx_t_2);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_2) != (0)) __PYX_ERR(5, 4859, __pyx_L1_error);
+  __pyx_t_1 = 0;
+  __pyx_t_2 = 0;
+  __pyx_r = __pyx_t_3;
+  __pyx_t_3 = 0;
+  goto __pyx_L0;
+
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("talib._ta_lib.stream_STOCHRSI", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_real);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+
+/* Python wrapper */
+static PyObject *__pyx_pw_5talib_7_ta_lib_655stream_SUB(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_654stream_SUB, "stream_SUB(ndarray real0, ndarray real1)\n\nSUB(real0, real1)\n\nVector Arithmetic Subtraction (Math Operators)\n\nInputs:\n    real0: (any ndarray)\n    real1: (any ndarray)\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_655stream_SUB = {"stream_SUB", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_655stream_SUB, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_654stream_SUB};
+static PyObject *__pyx_pw_5talib_7_ta_lib_655stream_SUB(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_real0 = 0;
+  PyArrayObject *__pyx_v_real1 = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("stream_SUB (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real0,&__pyx_mstate_global->__pyx_n_u_real1,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 4861, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4861, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4861, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
       }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_SUB", 0) < (0)) __PYX_ERR(5, 4861, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_SUB", 1, 2, 2, i); __PYX_ERR(5, 4861, __pyx_L3_error) }
+      }
+    } else if (unlikely(__pyx_nargs != 2)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4861, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4861, __pyx_L3_error)
     }
-    #endif
-    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  } else {
-    Py_ssize_t index = -1;
-    PyObject** temps[9] = {&__pyx_t_4,&__pyx_t_5,&__pyx_t_6,&__pyx_t_7,&__pyx_t_8,&__pyx_t_9,&__pyx_t_10,&__pyx_t_11,&__pyx_t_12};
-    __pyx_t_13 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 61, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_13);
-    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-    __pyx_t_14 = Py_TYPE(__pyx_t_13)->tp_iternext;
-    for (index=0; index < 9; index++) {
-      PyObject* item = __pyx_t_14(__pyx_t_13); if (unlikely(!item)) goto __pyx_L2_unpacking_failed;
-      __Pyx_GOTREF(item);
-      *(temps[index]) = item;
-    }
-    if (__Pyx_IternextUnpackEndCheck(__pyx_t_14(__pyx_t_13), 9) < 0) __PYX_ERR(0, 61, __pyx_L1_error)
-    __pyx_t_14 = NULL;
-    __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
-    goto __pyx_L3_unpacking_done;
-    __pyx_L2_unpacking_failed:;
-    __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
-    __pyx_t_14 = NULL;
-    if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
-    __PYX_ERR(0, 61, __pyx_L1_error)
-    __pyx_L3_unpacking_done:;
+    __pyx_v_real0 = ((PyArrayObject *)values[0]);
+    __pyx_v_real1 = ((PyArrayObject *)values[1]);
   }
-  if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_n_s_SMA, __pyx_t_4) < 0) __PYX_ERR(0, 61, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_n_s_EMA, __pyx_t_5) < 0) __PYX_ERR(0, 61, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-  if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_n_s_WMA, __pyx_t_6) < 0) __PYX_ERR(0, 61, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
-  if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_n_s_DEMA, __pyx_t_7) < 0) __PYX_ERR(0, 61, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
-  if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_n_s_TEMA, __pyx_t_8) < 0) __PYX_ERR(0, 61, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
-  if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_n_s_TRIMA, __pyx_t_9) < 0) __PYX_ERR(0, 61, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
-  if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_n_s_KAMA, __pyx_t_10) < 0) __PYX_ERR(0, 61, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
-  if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_n_s_MAMA, __pyx_t_11) < 0) __PYX_ERR(0, 61, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
-  if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_n_s_T3, __pyx_t_12) < 0) __PYX_ERR(0, 61, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("stream_SUB", 1, 2, 2, __pyx_nargs); __PYX_ERR(5, 4861, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_SUB", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real0), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real0", 0))) __PYX_ERR(5, 4863, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real1), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real1", 0))) __PYX_ERR(5, 4863, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_654stream_SUB(__pyx_self, __pyx_v_real0, __pyx_v_real1);
 
-  __pyx_t_3 = __Pyx_CyFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_7MA_Type_1__init__, 0, __pyx_n_s_MA_Type___init, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__26)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 63, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_n_s_init, __pyx_t_3) < 0) __PYX_ERR(0, 63, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
+  __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
 
-  __pyx_t_3 = __Pyx_CyFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_7MA_Type_3__getitem__, 0, __pyx_n_s_MA_Type___getitem, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__28)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 76, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_n_s_getitem, __pyx_t_3) < 0) __PYX_ERR(0, 76, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+static PyObject *__pyx_pf_5talib_7_ta_lib_654stream_SUB(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real0, PyArrayObject *__pyx_v_real1) {
+  npy_intp __pyx_v_length;
+  TA_RetCode __pyx_v_retCode;
+  double *__pyx_v_real0_data;
+  double *__pyx_v_real1_data;
+  int __pyx_v_outbegidx;
+  int __pyx_v_outnbelement;
+  double __pyx_v_outreal;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  npy_intp __pyx_t_2;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_SUB", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_real0);
+  __Pyx_INCREF((PyObject *)__pyx_v_real1);
 
-  __pyx_t_3 = __Pyx_Py3ClassCreate(__pyx_t_1, __pyx_n_s_MA_Type, __pyx_tuple__23, __pyx_t_2, NULL, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 60, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_MA_Type, __pyx_t_3) < 0) __PYX_ERR(0, 60, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4882, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_real0, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
+
+  __pyx_v_real0_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real0));
 
-  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_MA_Type); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 79, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4884, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 79, __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_MA_Type, __pyx_t_2) < 0) __PYX_ERR(0, 79, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF_SET(__pyx_v_real1, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
 
-  __pyx_t_2 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 81, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_NONE, __pyx_int_neg_1) < 0) __PYX_ERR(0, 81, __pyx_L1_error)
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_ta_func_unst_ids, __pyx_t_2) < 0) __PYX_ERR(0, 81, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_v_real1_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real1));
 
-  __Pyx_INCREF(__pyx_int_0);
-  __pyx_t_2 = __pyx_int_0;
-  __pyx_t_1 = PyList_New(24); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 82, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_INCREF(__pyx_n_s_ADX);
-  __Pyx_GIVEREF(__pyx_n_s_ADX);
-  PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_ADX);
-  __Pyx_INCREF(__pyx_n_s_ADXR);
-  __Pyx_GIVEREF(__pyx_n_s_ADXR);
-  PyList_SET_ITEM(__pyx_t_1, 1, __pyx_n_s_ADXR);
-  __Pyx_INCREF(__pyx_n_s_ATR);
-  __Pyx_GIVEREF(__pyx_n_s_ATR);
-  PyList_SET_ITEM(__pyx_t_1, 2, __pyx_n_s_ATR);
-  __Pyx_INCREF(__pyx_n_s_CMO);
-  __Pyx_GIVEREF(__pyx_n_s_CMO);
-  PyList_SET_ITEM(__pyx_t_1, 3, __pyx_n_s_CMO);
-  __Pyx_INCREF(__pyx_n_s_DX);
-  __Pyx_GIVEREF(__pyx_n_s_DX);
-  PyList_SET_ITEM(__pyx_t_1, 4, __pyx_n_s_DX);
-  __Pyx_INCREF(__pyx_n_s_EMA);
-  __Pyx_GIVEREF(__pyx_n_s_EMA);
-  PyList_SET_ITEM(__pyx_t_1, 5, __pyx_n_s_EMA);
-  __Pyx_INCREF(__pyx_n_s_HT_DCPERIOD);
-  __Pyx_GIVEREF(__pyx_n_s_HT_DCPERIOD);
-  PyList_SET_ITEM(__pyx_t_1, 6, __pyx_n_s_HT_DCPERIOD);
-  __Pyx_INCREF(__pyx_n_s_HT_DCPHASE);
-  __Pyx_GIVEREF(__pyx_n_s_HT_DCPHASE);
-  PyList_SET_ITEM(__pyx_t_1, 7, __pyx_n_s_HT_DCPHASE);
-  __Pyx_INCREF(__pyx_n_s_HT_PHASOR);
-  __Pyx_GIVEREF(__pyx_n_s_HT_PHASOR);
-  PyList_SET_ITEM(__pyx_t_1, 8, __pyx_n_s_HT_PHASOR);
-  __Pyx_INCREF(__pyx_n_s_HT_SINE);
-  __Pyx_GIVEREF(__pyx_n_s_HT_SINE);
-  PyList_SET_ITEM(__pyx_t_1, 9, __pyx_n_s_HT_SINE);
-  __Pyx_INCREF(__pyx_n_s_HT_TRENDLINE);
-  __Pyx_GIVEREF(__pyx_n_s_HT_TRENDLINE);
-  PyList_SET_ITEM(__pyx_t_1, 10, __pyx_n_s_HT_TRENDLINE);
-  __Pyx_INCREF(__pyx_n_s_HT_TRENDMODE);
-  __Pyx_GIVEREF(__pyx_n_s_HT_TRENDMODE);
-  PyList_SET_ITEM(__pyx_t_1, 11, __pyx_n_s_HT_TRENDMODE);
-  __Pyx_INCREF(__pyx_n_s_KAMA);
-  __Pyx_GIVEREF(__pyx_n_s_KAMA);
-  PyList_SET_ITEM(__pyx_t_1, 12, __pyx_n_s_KAMA);
-  __Pyx_INCREF(__pyx_n_s_MAMA);
-  __Pyx_GIVEREF(__pyx_n_s_MAMA);
-  PyList_SET_ITEM(__pyx_t_1, 13, __pyx_n_s_MAMA);
-  __Pyx_INCREF(__pyx_n_s_MFI);
-  __Pyx_GIVEREF(__pyx_n_s_MFI);
-  PyList_SET_ITEM(__pyx_t_1, 14, __pyx_n_s_MFI);
-  __Pyx_INCREF(__pyx_n_s_MINUS_DI);
-  __Pyx_GIVEREF(__pyx_n_s_MINUS_DI);
-  PyList_SET_ITEM(__pyx_t_1, 15, __pyx_n_s_MINUS_DI);
-  __Pyx_INCREF(__pyx_n_s_MINUS_DM);
-  __Pyx_GIVEREF(__pyx_n_s_MINUS_DM);
-  PyList_SET_ITEM(__pyx_t_1, 16, __pyx_n_s_MINUS_DM);
-  __Pyx_INCREF(__pyx_n_s_NATR);
-  __Pyx_GIVEREF(__pyx_n_s_NATR);
-  PyList_SET_ITEM(__pyx_t_1, 17, __pyx_n_s_NATR);
-  __Pyx_INCREF(__pyx_n_s_PLUS_DI);
-  __Pyx_GIVEREF(__pyx_n_s_PLUS_DI);
-  PyList_SET_ITEM(__pyx_t_1, 18, __pyx_n_s_PLUS_DI);
-  __Pyx_INCREF(__pyx_n_s_PLUS_DM);
-  __Pyx_GIVEREF(__pyx_n_s_PLUS_DM);
-  PyList_SET_ITEM(__pyx_t_1, 19, __pyx_n_s_PLUS_DM);
-  __Pyx_INCREF(__pyx_n_s_RSI);
-  __Pyx_GIVEREF(__pyx_n_s_RSI);
-  PyList_SET_ITEM(__pyx_t_1, 20, __pyx_n_s_RSI);
-  __Pyx_INCREF(__pyx_n_s_STOCHRSI);
-  __Pyx_GIVEREF(__pyx_n_s_STOCHRSI);
-  PyList_SET_ITEM(__pyx_t_1, 21, __pyx_n_s_STOCHRSI);
-  __Pyx_INCREF(__pyx_n_s_T3);
-  __Pyx_GIVEREF(__pyx_n_s_T3);
-  PyList_SET_ITEM(__pyx_t_1, 22, __pyx_n_s_T3);
-  __Pyx_INCREF(__pyx_n_s_ALL);
-  __Pyx_GIVEREF(__pyx_n_s_ALL);
-  PyList_SET_ITEM(__pyx_t_1, 23, __pyx_n_s_ALL);
-  __pyx_t_3 = __pyx_t_1; __Pyx_INCREF(__pyx_t_3); __pyx_t_15 = 0;
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  for (;;) {
-    if (__pyx_t_15 >= 24) break;
-    #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-    __pyx_t_1 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_15); __Pyx_INCREF(__pyx_t_1); __pyx_t_15++; if (unlikely(0 < 0)) __PYX_ERR(0, 82, __pyx_L1_error)
-    #else
-    __pyx_t_1 = PySequence_ITEM(__pyx_t_3, __pyx_t_15); __pyx_t_15++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 82, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_1);
-    #endif
-    if (PyDict_SetItem(__pyx_d, __pyx_n_s_name, __pyx_t_1) < 0) __PYX_ERR(0, 82, __pyx_L1_error)
-    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-    if (PyDict_SetItem(__pyx_d, __pyx_n_s_i, __pyx_t_2) < 0) __PYX_ERR(0, 82, __pyx_L1_error)
-    __pyx_t_1 = __Pyx_PyInt_AddObjC(__pyx_t_2, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 82, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_1);
-    __Pyx_DECREF(__pyx_t_2);
-    __pyx_t_2 = __pyx_t_1;
-    __pyx_t_1 = 0;
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_real0, __pyx_v_real1); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 4886, __pyx_L1_error)
+  __pyx_v_length = __pyx_t_2;
 
-    __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_i); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 88, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_1);
-    __Pyx_GetModuleGlobalName(__pyx_t_12, __pyx_n_s_ta_func_unst_ids); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 88, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_12);
-    __Pyx_GetModuleGlobalName(__pyx_t_11, __pyx_n_s_name); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 88, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_11);
-    if (unlikely(PyObject_SetItem(__pyx_t_12, __pyx_t_11, __pyx_t_1) < 0)) __PYX_ERR(0, 88, __pyx_L1_error)
-    __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
-    __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
-    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
 
-  }
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_v_retCode = TA_SUB((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real0_data, __pyx_v_real1_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_7_ta_set_unstable_period, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 90, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_ta_set_unstable_period, __pyx_t_2) < 0) __PYX_ERR(0, 90, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_SUB, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4889, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_9_ta_get_unstable_period, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 96, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_ta_get_unstable_period, __pyx_t_2) < 0) __PYX_ERR(0, 96, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4890, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_11_ta_set_compatibility, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 102, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_ta_set_compatibility, __pyx_t_2) < 0) __PYX_ERR(0, 102, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_13_ta_get_compatibility, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 107, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_ta_get_compatibility, __pyx_t_2) < 0) __PYX_ERR(0, 107, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("talib._ta_lib.stream_SUB", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_real0);
+  __Pyx_XDECREF((PyObject *)__pyx_v_real1);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
 
-  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_tuple__37); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 112, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_tuple__37, __pyx_n_s_CandleSettingType, __pyx_n_s_CandleSettingType, (PyObject *) NULL, __pyx_n_s_talib__ta_lib, (PyObject *) NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 112, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
 
-  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_range, __pyx_tuple__38, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 115, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if ((likely(PyTuple_CheckExact(__pyx_t_1))) || (PyList_CheckExact(__pyx_t_1))) {
-    PyObject* sequence = __pyx_t_1;
-    Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
-    if (unlikely(size != 12)) {
-      if (size > 12) __Pyx_RaiseTooManyValuesError(12);
-      else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
-      __PYX_ERR(0, 113, __pyx_L1_error)
-    }
-    #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-    if (likely(PyTuple_CheckExact(sequence))) {
-      __pyx_t_11 = PyTuple_GET_ITEM(sequence, 0); 
-      __pyx_t_12 = PyTuple_GET_ITEM(sequence, 1); 
-      __pyx_t_10 = PyTuple_GET_ITEM(sequence, 2); 
-      __pyx_t_9 = PyTuple_GET_ITEM(sequence, 3); 
-      __pyx_t_8 = PyTuple_GET_ITEM(sequence, 4); 
-      __pyx_t_7 = PyTuple_GET_ITEM(sequence, 5); 
-      __pyx_t_6 = PyTuple_GET_ITEM(sequence, 6); 
-      __pyx_t_5 = PyTuple_GET_ITEM(sequence, 7); 
-      __pyx_t_4 = PyTuple_GET_ITEM(sequence, 8); 
-      __pyx_t_13 = PyTuple_GET_ITEM(sequence, 9); 
-      __pyx_t_16 = PyTuple_GET_ITEM(sequence, 10); 
-      __pyx_t_17 = PyTuple_GET_ITEM(sequence, 11); 
-    } else {
-      __pyx_t_11 = PyList_GET_ITEM(sequence, 0); 
-      __pyx_t_12 = PyList_GET_ITEM(sequence, 1); 
-      __pyx_t_10 = PyList_GET_ITEM(sequence, 2); 
-      __pyx_t_9 = PyList_GET_ITEM(sequence, 3); 
-      __pyx_t_8 = PyList_GET_ITEM(sequence, 4); 
-      __pyx_t_7 = PyList_GET_ITEM(sequence, 5); 
-      __pyx_t_6 = PyList_GET_ITEM(sequence, 6); 
-      __pyx_t_5 = PyList_GET_ITEM(sequence, 7); 
-      __pyx_t_4 = PyList_GET_ITEM(sequence, 8); 
-      __pyx_t_13 = PyList_GET_ITEM(sequence, 9); 
-      __pyx_t_16 = PyList_GET_ITEM(sequence, 10); 
-      __pyx_t_17 = PyList_GET_ITEM(sequence, 11); 
-    }
-    __Pyx_INCREF(__pyx_t_11);
-    __Pyx_INCREF(__pyx_t_12);
-    __Pyx_INCREF(__pyx_t_10);
-    __Pyx_INCREF(__pyx_t_9);
-    __Pyx_INCREF(__pyx_t_8);
-    __Pyx_INCREF(__pyx_t_7);
-    __Pyx_INCREF(__pyx_t_6);
-    __Pyx_INCREF(__pyx_t_5);
-    __Pyx_INCREF(__pyx_t_4);
-    __Pyx_INCREF(__pyx_t_13);
-    __Pyx_INCREF(__pyx_t_16);
-    __Pyx_INCREF(__pyx_t_17);
-    #else
-    {
-      Py_ssize_t i;
-      PyObject** temps[12] = {&__pyx_t_11,&__pyx_t_12,&__pyx_t_10,&__pyx_t_9,&__pyx_t_8,&__pyx_t_7,&__pyx_t_6,&__pyx_t_5,&__pyx_t_4,&__pyx_t_13,&__pyx_t_16,&__pyx_t_17};
-      for (i=0; i < 12; i++) {
-        PyObject* item = PySequence_ITEM(sequence, i); if (unlikely(!item)) __PYX_ERR(0, 113, __pyx_L1_error)
-        __Pyx_GOTREF(item);
-        *(temps[i]) = item;
+/* Python wrapper */
+static PyObject *__pyx_pw_5talib_7_ta_lib_657stream_SUM(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_656stream_SUM, "stream_SUM(ndarray real, int timeperiod=-0x80000000)\n\nSUM(real[, timeperiod=?])\n\nSummation (Math Operators)\n\nInputs:\n    real: (any ndarray)\nParameters:\n    timeperiod: 30\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_657stream_SUM = {"stream_SUM", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_657stream_SUM, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_656stream_SUM};
+static PyObject *__pyx_pw_5talib_7_ta_lib_657stream_SUM(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_real = 0;
+  int __pyx_v_timeperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("stream_SUM (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 4892, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4892, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4892, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_SUM", 0) < (0)) __PYX_ERR(5, 4892, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_SUM", 0, 1, 2, i); __PYX_ERR(5, 4892, __pyx_L3_error) }
+      }
+    } else {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4892, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4892, __pyx_L3_error)
+        break;
+        default: goto __pyx_L5_argtuple_error;
       }
     }
-    #endif
-    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  } else {
-    Py_ssize_t index = -1;
-    PyObject** temps[12] = {&__pyx_t_11,&__pyx_t_12,&__pyx_t_10,&__pyx_t_9,&__pyx_t_8,&__pyx_t_7,&__pyx_t_6,&__pyx_t_5,&__pyx_t_4,&__pyx_t_13,&__pyx_t_16,&__pyx_t_17};
-    __pyx_t_18 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 113, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_18);
-    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-    __pyx_t_14 = Py_TYPE(__pyx_t_18)->tp_iternext;
-    for (index=0; index < 12; index++) {
-      PyObject* item = __pyx_t_14(__pyx_t_18); if (unlikely(!item)) goto __pyx_L6_unpacking_failed;
-      __Pyx_GOTREF(item);
-      *(temps[index]) = item;
+    __pyx_v_real = ((PyArrayObject *)values[0]);
+    if (values[1]) {
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 4894, __pyx_L3_error)
+    } else {
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
     }
-    if (__Pyx_IternextUnpackEndCheck(__pyx_t_14(__pyx_t_18), 12) < 0) __PYX_ERR(0, 113, __pyx_L1_error)
-    __pyx_t_14 = NULL;
-    __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
-    goto __pyx_L7_unpacking_done;
-    __pyx_L6_unpacking_failed:;
-    __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
-    __pyx_t_14 = NULL;
-    if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
-    __PYX_ERR(0, 113, __pyx_L1_error)
-    __pyx_L7_unpacking_done:;
   }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("stream_SUM", 0, 1, 2, __pyx_nargs); __PYX_ERR(5, 4892, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_SUM", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 4894, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_656stream_SUM(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
 
-  if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_BodyLong, __pyx_t_11) < 0) __PYX_ERR(0, 113, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
-  if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_BodyVeryLong, __pyx_t_12) < 0) __PYX_ERR(0, 113, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
-  if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_BodyShort, __pyx_t_10) < 0) __PYX_ERR(0, 113, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
-  if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_BodyDoji, __pyx_t_9) < 0) __PYX_ERR(0, 113, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
-  if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_ShadowLong, __pyx_t_8) < 0) __PYX_ERR(0, 113, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
-  if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_ShadowVeryLong, __pyx_t_7) < 0) __PYX_ERR(0, 113, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
-  if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_ShadowShort, __pyx_t_6) < 0) __PYX_ERR(0, 114, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
-  if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_ShadowVeryShort, __pyx_t_5) < 0) __PYX_ERR(0, 114, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-  if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_Near, __pyx_t_4) < 0) __PYX_ERR(0, 114, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_Far, __pyx_t_13) < 0) __PYX_ERR(0, 114, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
-  if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_Equal, __pyx_t_16) < 0) __PYX_ERR(0, 114, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
-  if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_AllCandleSettings, __pyx_t_17) < 0) __PYX_ERR(0, 114, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
+  __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_5talib_7_ta_lib_656stream_SUM(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
+  npy_intp __pyx_v_length;
+  TA_RetCode __pyx_v_retCode;
+  double *__pyx_v_real_data;
+  int __pyx_v_outbegidx;
+  int __pyx_v_outnbelement;
+  double __pyx_v_outreal;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_SUM", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_1 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_CandleSettingType, __pyx_tuple__37, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 112, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4913, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_CandleSettingType, __pyx_t_1) < 0) __PYX_ERR(0, 112, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
 
-  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_CandleSettingType); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 117, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 117, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_CandleSettingType, __pyx_t_3) < 0) __PYX_ERR(0, 117, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real));
 
-  __pyx_t_3 = __Pyx_CalculateMetaclass(NULL, __pyx_tuple__39); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 119, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_2 = __Pyx_Py3MetaclassPrepare(__pyx_t_3, __pyx_tuple__39, __pyx_n_s_RangeType, __pyx_n_s_RangeType, (PyObject *) NULL, __pyx_n_s_talib__ta_lib, (PyObject *) NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 119, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
-  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_range, __pyx_tuple__40, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 120, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if ((likely(PyTuple_CheckExact(__pyx_t_1))) || (PyList_CheckExact(__pyx_t_1))) {
-    PyObject* sequence = __pyx_t_1;
-    Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
-    if (unlikely(size != 3)) {
-      if (size > 3) __Pyx_RaiseTooManyValuesError(3);
-      else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
-      __PYX_ERR(0, 120, __pyx_L1_error)
-    }
-    #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-    if (likely(PyTuple_CheckExact(sequence))) {
-      __pyx_t_17 = PyTuple_GET_ITEM(sequence, 0); 
-      __pyx_t_16 = PyTuple_GET_ITEM(sequence, 1); 
-      __pyx_t_13 = PyTuple_GET_ITEM(sequence, 2); 
-    } else {
-      __pyx_t_17 = PyList_GET_ITEM(sequence, 0); 
-      __pyx_t_16 = PyList_GET_ITEM(sequence, 1); 
-      __pyx_t_13 = PyList_GET_ITEM(sequence, 2); 
-    }
-    __Pyx_INCREF(__pyx_t_17);
-    __Pyx_INCREF(__pyx_t_16);
-    __Pyx_INCREF(__pyx_t_13);
-    #else
-    __pyx_t_17 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 120, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_17);
-    __pyx_t_16 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 120, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_16);
-    __pyx_t_13 = PySequence_ITEM(sequence, 2); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 120, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_13);
-    #endif
-    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  } else {
-    Py_ssize_t index = -1;
-    __pyx_t_4 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 120, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_4);
-    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-    __pyx_t_14 = Py_TYPE(__pyx_t_4)->tp_iternext;
-    index = 0; __pyx_t_17 = __pyx_t_14(__pyx_t_4); if (unlikely(!__pyx_t_17)) goto __pyx_L8_unpacking_failed;
-    __Pyx_GOTREF(__pyx_t_17);
-    index = 1; __pyx_t_16 = __pyx_t_14(__pyx_t_4); if (unlikely(!__pyx_t_16)) goto __pyx_L8_unpacking_failed;
-    __Pyx_GOTREF(__pyx_t_16);
-    index = 2; __pyx_t_13 = __pyx_t_14(__pyx_t_4); if (unlikely(!__pyx_t_13)) goto __pyx_L8_unpacking_failed;
-    __Pyx_GOTREF(__pyx_t_13);
-    if (__Pyx_IternextUnpackEndCheck(__pyx_t_14(__pyx_t_4), 3) < 0) __PYX_ERR(0, 120, __pyx_L1_error)
-    __pyx_t_14 = NULL;
-    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-    goto __pyx_L9_unpacking_done;
-    __pyx_L8_unpacking_failed:;
-    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-    __pyx_t_14 = NULL;
-    if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
-    __PYX_ERR(0, 120, __pyx_L1_error)
-    __pyx_L9_unpacking_done:;
-  }
-  if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_n_s_RealBody, __pyx_t_17) < 0) __PYX_ERR(0, 120, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
-  if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_n_s_HighLow, __pyx_t_16) < 0) __PYX_ERR(0, 120, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
-  if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_n_s_Shadows, __pyx_t_13) < 0) __PYX_ERR(0, 120, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+  __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
 
-  __pyx_t_1 = __Pyx_Py3ClassCreate(__pyx_t_3, __pyx_n_s_RangeType, __pyx_tuple__39, __pyx_t_2, NULL, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 119, __pyx_L1_error)
+  __pyx_v_retCode = TA_SUM((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
+
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_SUM, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4918, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_RangeType, __pyx_t_1) < 0) __PYX_ERR(0, 119, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
-  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_RangeType); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 122, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 122, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_RangeType, __pyx_t_2) < 0) __PYX_ERR(0, 122, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_15_ta_set_candle_settings, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 124, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_ta_set_candle_settings, __pyx_t_2) < 0) __PYX_ERR(0, 124, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4919, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_17_ta_restore_candle_default_settings, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 129, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_ta_restore_candle_default_setti, __pyx_t_2) < 0) __PYX_ERR(0, 129, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 2, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_INCREF(__pyx_n_s_nan);
-  __Pyx_GIVEREF(__pyx_n_s_nan);
-  PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_nan);
-  __pyx_t_3 = __Pyx_Import(__pyx_n_s_numpy, __pyx_t_2, -1); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 2, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_3, __pyx_n_s_nan); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 2, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_nan, __pyx_t_2) < 0) __PYX_ERR(2, 2, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("talib._ta_lib.stream_SUM", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_real);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
 
-  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_nan); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 7, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_19 = __pyx_PyFloat_AsDouble(__pyx_t_3); if (unlikely((__pyx_t_19 == (double)-1) && PyErr_Occurred())) __PYX_ERR(2, 7, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __pyx_v_5talib_7_ta_lib_NaN = __pyx_t_19;
 
-  __pyx_t_20 = __pyx_f_5numpy_import_array(); if (unlikely(__pyx_t_20 == ((int)-1))) __PYX_ERR(2, 15, __pyx_L1_error)
+/* Python wrapper */
+static PyObject *__pyx_pw_5talib_7_ta_lib_659stream_T3(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_658stream_T3, "stream_T3(ndarray real, int timeperiod=-0x80000000, double vfactor=-4e37)\n\nT3(real[, timeperiod=?, vfactor=?])\n\nTriple Exponential Moving Average (T3) (Overlap Studies)\n\nInputs:\n    real: (any ndarray)\nParameters:\n    timeperiod: 5\n    vfactor: 0.7\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_659stream_T3 = {"stream_T3", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_659stream_T3, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_658stream_T3};
+static PyObject *__pyx_pw_5talib_7_ta_lib_659stream_T3(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_real = 0;
+  int __pyx_v_timeperiod;
+  double __pyx_v_vfactor;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[3] = {0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("stream_T3 (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,&__pyx_mstate_global->__pyx_n_u_vfactor,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 4921, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 4921, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4921, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4921, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_T3", 0) < (0)) __PYX_ERR(5, 4921, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_T3", 0, 1, 3, i); __PYX_ERR(5, 4921, __pyx_L3_error) }
+      }
+    } else {
+      switch (__pyx_nargs) {
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 4921, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 4921, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4921, __pyx_L3_error)
+        break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+    }
+    __pyx_v_real = ((PyArrayObject *)values[0]);
+    if (values[1]) {
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 4923, __pyx_L3_error)
+    } else {
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
+    }
+    if (values[2]) {
+      __pyx_v_vfactor = __Pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_vfactor == (double)-1) && PyErr_Occurred())) __PYX_ERR(5, 4923, __pyx_L3_error)
+    } else {
+      __pyx_v_vfactor = ((double)((double)-4e37));
+    }
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("stream_T3", 0, 1, 3, __pyx_nargs); __PYX_ERR(5, 4921, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_T3", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 4923, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_658stream_T3(__pyx_self, __pyx_v_real, __pyx_v_timeperiod, __pyx_v_vfactor);
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_19ACOS, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 144, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_ACOS, __pyx_t_3) < 0) __PYX_ERR(2, 144, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
+  __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_21AD, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 173, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_AD, __pyx_t_3) < 0) __PYX_ERR(2, 173, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+static PyObject *__pyx_pf_5talib_7_ta_lib_658stream_T3(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod, double __pyx_v_vfactor) {
+  npy_intp __pyx_v_length;
+  TA_RetCode __pyx_v_retCode;
+  double *__pyx_v_real_data;
+  int __pyx_v_outbegidx;
+  int __pyx_v_outnbelement;
+  double __pyx_v_outreal;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_T3", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_23ADD, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 205, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_ADD, __pyx_t_3) < 0) __PYX_ERR(2, 205, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4943, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_25ADOSC, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 236, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_ADOSC, __pyx_t_3) < 0) __PYX_ERR(2, 236, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real));
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_27ADX, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 271, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_ADX, __pyx_t_3) < 0) __PYX_ERR(2, 271, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_29ADXR, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 304, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_ADXR, __pyx_t_3) < 0) __PYX_ERR(2, 304, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_31APO, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 337, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_APO, __pyx_t_3) < 0) __PYX_ERR(2, 337, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_v_retCode = TA_T3((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, __pyx_v_vfactor, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_33AROON, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 370, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_AROON, __pyx_t_3) < 0) __PYX_ERR(2, 370, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_T3, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4948, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_35AROONOSC, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 405, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_AROONOSC, __pyx_t_3) < 0) __PYX_ERR(2, 405, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4949, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_37ASIN, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 437, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_ASIN, __pyx_t_3) < 0) __PYX_ERR(2, 437, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_39ATAN, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 466, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_ATAN, __pyx_t_3) < 0) __PYX_ERR(2, 466, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("talib._ta_lib.stream_T3", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_real);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_41ATR, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 495, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_ATR, __pyx_t_3) < 0) __PYX_ERR(2, 495, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_43AVGPRICE, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 528, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_AVGPRICE, __pyx_t_3) < 0) __PYX_ERR(2, 528, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+/* Python wrapper */
+static PyObject *__pyx_pw_5talib_7_ta_lib_661stream_TAN(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_660stream_TAN, "stream_TAN(ndarray real)\n\nTAN(real)\n\nVector Trigonometric Tan (Math Transform)\n\nInputs:\n    real: (any ndarray)\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_661stream_TAN = {"stream_TAN", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_661stream_TAN, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_660stream_TAN};
+static PyObject *__pyx_pw_5talib_7_ta_lib_661stream_TAN(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_real = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("stream_TAN (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 4951, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4951, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_TAN", 0) < (0)) __PYX_ERR(5, 4951, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_TAN", 1, 1, 1, i); __PYX_ERR(5, 4951, __pyx_L3_error) }
+      }
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4951, __pyx_L3_error)
+    }
+    __pyx_v_real = ((PyArrayObject *)values[0]);
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("stream_TAN", 1, 1, 1, __pyx_nargs); __PYX_ERR(5, 4951, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_TAN", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 4953, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_660stream_TAN(__pyx_self, __pyx_v_real);
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_45BBANDS, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 560, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_BBANDS, __pyx_t_3) < 0) __PYX_ERR(2, 560, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
+  __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_47BETA, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 600, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_BETA, __pyx_t_3) < 0) __PYX_ERR(2, 600, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+static PyObject *__pyx_pf_5talib_7_ta_lib_660stream_TAN(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) {
+  npy_intp __pyx_v_length;
+  TA_RetCode __pyx_v_retCode;
+  double *__pyx_v_real_data;
+  int __pyx_v_outbegidx;
+  int __pyx_v_outnbelement;
+  double __pyx_v_outreal;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_TAN", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_49BOP, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 633, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_BOP, __pyx_t_3) < 0) __PYX_ERR(2, 633, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4970, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_51CCI, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 665, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_CCI, __pyx_t_3) < 0) __PYX_ERR(2, 665, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real));
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_53CDL2CROWS, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 698, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_CDL2CROWS, __pyx_t_3) < 0) __PYX_ERR(2, 698, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_55CDL3BLACKCROWS, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 730, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_CDL3BLACKCROWS, __pyx_t_3) < 0) __PYX_ERR(2, 730, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_57CDL3INSIDE, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 762, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_CDL3INSIDE, __pyx_t_3) < 0) __PYX_ERR(2, 762, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_v_retCode = TA_TAN((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_59CDL3LINESTRIKE, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 794, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_CDL3LINESTRIKE, __pyx_t_3) < 0) __PYX_ERR(2, 794, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_TAN, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4975, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_61CDL3OUTSIDE, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 826, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_CDL3OUTSIDE, __pyx_t_3) < 0) __PYX_ERR(2, 826, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4976, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_63CDL3STARSINSOUTH, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 858, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_CDL3STARSINSOUTH, __pyx_t_3) < 0) __PYX_ERR(2, 858, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_65CDL3WHITESOLDIERS, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 890, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_CDL3WHITESOLDIERS, __pyx_t_3) < 0) __PYX_ERR(2, 890, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("talib._ta_lib.stream_TAN", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_real);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_67CDLABANDONEDBABY, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 922, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLABANDONEDBABY, __pyx_t_3) < 0) __PYX_ERR(2, 922, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_69CDLADVANCEBLOCK, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 956, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLADVANCEBLOCK, __pyx_t_3) < 0) __PYX_ERR(2, 956, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+/* Python wrapper */
+static PyObject *__pyx_pw_5talib_7_ta_lib_663stream_TANH(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_662stream_TANH, "stream_TANH(ndarray real)\n\nTANH(real)\n\nVector Trigonometric Tanh (Math Transform)\n\nInputs:\n    real: (any ndarray)\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_663stream_TANH = {"stream_TANH", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_663stream_TANH, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_662stream_TANH};
+static PyObject *__pyx_pw_5talib_7_ta_lib_663stream_TANH(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_real = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("stream_TANH (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 4978, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4978, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_TANH", 0) < (0)) __PYX_ERR(5, 4978, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_TANH", 1, 1, 1, i); __PYX_ERR(5, 4978, __pyx_L3_error) }
+      }
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 4978, __pyx_L3_error)
+    }
+    __pyx_v_real = ((PyArrayObject *)values[0]);
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("stream_TANH", 1, 1, 1, __pyx_nargs); __PYX_ERR(5, 4978, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_TANH", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 4980, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_662stream_TANH(__pyx_self, __pyx_v_real);
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_71CDLBELTHOLD, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 988, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLBELTHOLD, __pyx_t_3) < 0) __PYX_ERR(2, 988, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
+  __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_73CDLBREAKAWAY, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1020, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLBREAKAWAY, __pyx_t_3) < 0) __PYX_ERR(2, 1020, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+static PyObject *__pyx_pf_5talib_7_ta_lib_662stream_TANH(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) {
+  npy_intp __pyx_v_length;
+  TA_RetCode __pyx_v_retCode;
+  double *__pyx_v_real_data;
+  int __pyx_v_outbegidx;
+  int __pyx_v_outnbelement;
+  double __pyx_v_outreal;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_TANH", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_75CDLCLOSINGMARUBOZU, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1052, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLCLOSINGMARUBOZU, __pyx_t_3) < 0) __PYX_ERR(2, 1052, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4997, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_77CDLCONCEALBABYSWALL, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1084, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLCONCEALBABYSWALL, __pyx_t_3) < 0) __PYX_ERR(2, 1084, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real));
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_79CDLCOUNTERATTACK, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1116, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLCOUNTERATTACK, __pyx_t_3) < 0) __PYX_ERR(2, 1116, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_81CDLDARKCLOUDCOVER, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1148, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLDARKCLOUDCOVER, __pyx_t_3) < 0) __PYX_ERR(2, 1148, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_83CDLDOJI, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1182, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLDOJI, __pyx_t_3) < 0) __PYX_ERR(2, 1182, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_v_retCode = TA_TANH((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_85CDLDOJISTAR, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1214, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLDOJISTAR, __pyx_t_3) < 0) __PYX_ERR(2, 1214, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_TANH, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 5002, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_87CDLDRAGONFLYDOJI, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1246, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLDRAGONFLYDOJI, __pyx_t_3) < 0) __PYX_ERR(2, 1246, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 5003, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_89CDLENGULFING, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1278, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLENGULFING, __pyx_t_3) < 0) __PYX_ERR(2, 1278, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_91CDLEVENINGDOJISTAR, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1310, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLEVENINGDOJISTAR, __pyx_t_3) < 0) __PYX_ERR(2, 1310, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("talib._ta_lib.stream_TANH", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_real);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_93CDLEVENINGSTAR, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1344, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLEVENINGSTAR, __pyx_t_3) < 0) __PYX_ERR(2, 1344, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_95CDLGAPSIDESIDEWHITE, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1378, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLGAPSIDESIDEWHITE, __pyx_t_3) < 0) __PYX_ERR(2, 1378, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+/* Python wrapper */
+static PyObject *__pyx_pw_5talib_7_ta_lib_665stream_TEMA(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_664stream_TEMA, "stream_TEMA(ndarray real, int timeperiod=-0x80000000)\n\nTEMA(real[, timeperiod=?])\n\nTriple Exponential Moving Average (Overlap Studies)\n\nInputs:\n    real: (any ndarray)\nParameters:\n    timeperiod: 30\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_665stream_TEMA = {"stream_TEMA", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_665stream_TEMA, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_664stream_TEMA};
+static PyObject *__pyx_pw_5talib_7_ta_lib_665stream_TEMA(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_real = 0;
+  int __pyx_v_timeperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("stream_TEMA (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 5005, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 5005, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 5005, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_TEMA", 0) < (0)) __PYX_ERR(5, 5005, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_TEMA", 0, 1, 2, i); __PYX_ERR(5, 5005, __pyx_L3_error) }
+      }
+    } else {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 5005, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 5005, __pyx_L3_error)
+        break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+    }
+    __pyx_v_real = ((PyArrayObject *)values[0]);
+    if (values[1]) {
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 5007, __pyx_L3_error)
+    } else {
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
+    }
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("stream_TEMA", 0, 1, 2, __pyx_nargs); __PYX_ERR(5, 5005, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_TEMA", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 5007, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_664stream_TEMA(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_97CDLGRAVESTONEDOJI, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1410, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLGRAVESTONEDOJI, __pyx_t_3) < 0) __PYX_ERR(2, 1410, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
+  __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_99CDLHAMMER, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1442, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLHAMMER, __pyx_t_3) < 0) __PYX_ERR(2, 1442, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+static PyObject *__pyx_pf_5talib_7_ta_lib_664stream_TEMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
+  npy_intp __pyx_v_length;
+  TA_RetCode __pyx_v_retCode;
+  double *__pyx_v_real_data;
+  int __pyx_v_outbegidx;
+  int __pyx_v_outnbelement;
+  double __pyx_v_outreal;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_TEMA", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_101CDLHANGINGMAN, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1474, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLHANGINGMAN, __pyx_t_3) < 0) __PYX_ERR(2, 1474, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 5026, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_103CDLHARAMI, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1506, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLHARAMI, __pyx_t_3) < 0) __PYX_ERR(2, 1506, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real));
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_105CDLHARAMICROSS, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1538, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLHARAMICROSS, __pyx_t_3) < 0) __PYX_ERR(2, 1538, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_107CDLHIGHWAVE, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1570, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLHIGHWAVE, __pyx_t_3) < 0) __PYX_ERR(2, 1570, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_109CDLHIKKAKE, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1602, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLHIKKAKE, __pyx_t_3) < 0) __PYX_ERR(2, 1602, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_v_retCode = TA_TEMA((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_111CDLHIKKAKEMOD, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1634, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLHIKKAKEMOD, __pyx_t_3) < 0) __PYX_ERR(2, 1634, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_TEMA, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 5031, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_113CDLHOMINGPIGEON, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1666, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLHOMINGPIGEON, __pyx_t_3) < 0) __PYX_ERR(2, 1666, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 5032, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_115CDLIDENTICAL3CROWS, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1698, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLIDENTICAL3CROWS, __pyx_t_3) < 0) __PYX_ERR(2, 1698, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_117CDLINNECK, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1730, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLINNECK, __pyx_t_3) < 0) __PYX_ERR(2, 1730, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("talib._ta_lib.stream_TEMA", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_real);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_119CDLINVERTEDHAMMER, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1762, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLINVERTEDHAMMER, __pyx_t_3) < 0) __PYX_ERR(2, 1762, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_121CDLKICKING, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1794, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLKICKING, __pyx_t_3) < 0) __PYX_ERR(2, 1794, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+/* Python wrapper */
+static PyObject *__pyx_pw_5talib_7_ta_lib_667stream_TRANGE(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_666stream_TRANGE, "stream_TRANGE(ndarray high, ndarray low, ndarray close)\n\nTRANGE(high, low, close)\n\nTrue Range (Volatility Indicators)\n\nInputs:\n    prices: ['high', 'low', 'close']\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_667stream_TRANGE = {"stream_TRANGE", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_667stream_TRANGE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_666stream_TRANGE};
+static PyObject *__pyx_pw_5talib_7_ta_lib_667stream_TRANGE(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_high = 0;
+  PyArrayObject *__pyx_v_low = 0;
+  PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[3] = {0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("stream_TRANGE (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 5034, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 5034, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 5034, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 5034, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_TRANGE", 0) < (0)) __PYX_ERR(5, 5034, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 3; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_TRANGE", 1, 3, 3, i); __PYX_ERR(5, 5034, __pyx_L3_error) }
+      }
+    } else if (unlikely(__pyx_nargs != 3)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 5034, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 5034, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 5034, __pyx_L3_error)
+    }
+    __pyx_v_high = ((PyArrayObject *)values[0]);
+    __pyx_v_low = ((PyArrayObject *)values[1]);
+    __pyx_v_close = ((PyArrayObject *)values[2]);
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("stream_TRANGE", 1, 3, 3, __pyx_nargs); __PYX_ERR(5, 5034, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_TRANGE", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 5036, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 5036, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 5036, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_666stream_TRANGE(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_123CDLKICKINGBYLENGTH, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1826, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLKICKINGBYLENGTH, __pyx_t_3) < 0) __PYX_ERR(2, 1826, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
+  __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_125CDLLADDERBOTTOM, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1858, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLLADDERBOTTOM, __pyx_t_3) < 0) __PYX_ERR(2, 1858, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+static PyObject *__pyx_pf_5talib_7_ta_lib_666stream_TRANGE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+  npy_intp __pyx_v_length;
+  TA_RetCode __pyx_v_retCode;
+  double *__pyx_v_high_data;
+  double *__pyx_v_low_data;
+  double *__pyx_v_close_data;
+  int __pyx_v_outbegidx;
+  int __pyx_v_outnbelement;
+  double __pyx_v_outreal;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  npy_intp __pyx_t_2;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_TRANGE", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_high);
+  __Pyx_INCREF((PyObject *)__pyx_v_low);
+  __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_127CDLLONGLEGGEDDOJI, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1890, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLLONGLEGGEDDOJI, __pyx_t_3) < 0) __PYX_ERR(2, 1890, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 5055, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_129CDLLONGLINE, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1922, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLLONGLINE, __pyx_t_3) < 0) __PYX_ERR(2, 1922, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high));
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_131CDLMARUBOZU, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1954, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLMARUBOZU, __pyx_t_3) < 0) __PYX_ERR(2, 1954, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 5057, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_133CDLMATCHINGLOW, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1986, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLMATCHINGLOW, __pyx_t_3) < 0) __PYX_ERR(2, 1986, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low));
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_135CDLMATHOLD, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 2018, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLMATHOLD, __pyx_t_3) < 0) __PYX_ERR(2, 2018, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 5059, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_137CDLMORNINGDOJISTAR, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 2052, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLMORNINGDOJISTAR, __pyx_t_3) < 0) __PYX_ERR(2, 2052, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close));
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_139CDLMORNINGSTAR, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 2086, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLMORNINGSTAR, __pyx_t_3) < 0) __PYX_ERR(2, 2086, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 5061, __pyx_L1_error)
+  __pyx_v_length = __pyx_t_2;
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_141CDLONNECK, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 2120, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLONNECK, __pyx_t_3) < 0) __PYX_ERR(2, 2120, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_143CDLPIERCING, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 2152, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLPIERCING, __pyx_t_3) < 0) __PYX_ERR(2, 2152, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_v_retCode = TA_TRANGE((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_145CDLRICKSHAWMAN, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 2184, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLRICKSHAWMAN, __pyx_t_3) < 0) __PYX_ERR(2, 2184, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_TRANGE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 5064, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_147CDLRISEFALL3METHODS, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 2216, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLRISEFALL3METHODS, __pyx_t_3) < 0) __PYX_ERR(2, 2216, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 5065, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_149CDLSEPARATINGLINES, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 2248, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLSEPARATINGLINES, __pyx_t_3) < 0) __PYX_ERR(2, 2248, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_151CDLSHOOTINGSTAR, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 2280, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLSHOOTINGSTAR, __pyx_t_3) < 0) __PYX_ERR(2, 2280, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("talib._ta_lib.stream_TRANGE", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_high);
+  __Pyx_XDECREF((PyObject *)__pyx_v_low);
+  __Pyx_XDECREF((PyObject *)__pyx_v_close);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_153CDLSHORTLINE, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 2312, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLSHORTLINE, __pyx_t_3) < 0) __PYX_ERR(2, 2312, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_155CDLSPINNINGTOP, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 2344, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLSPINNINGTOP, __pyx_t_3) < 0) __PYX_ERR(2, 2344, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+/* Python wrapper */
+static PyObject *__pyx_pw_5talib_7_ta_lib_669stream_TRIMA(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_668stream_TRIMA, "stream_TRIMA(ndarray real, int timeperiod=-0x80000000)\n\nTRIMA(real[, timeperiod=?])\n\nTriangular Moving Average (Overlap Studies)\n\nInputs:\n    real: (any ndarray)\nParameters:\n    timeperiod: 30\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_669stream_TRIMA = {"stream_TRIMA", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_669stream_TRIMA, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_668stream_TRIMA};
+static PyObject *__pyx_pw_5talib_7_ta_lib_669stream_TRIMA(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_real = 0;
+  int __pyx_v_timeperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("stream_TRIMA (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 5067, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 5067, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 5067, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_TRIMA", 0) < (0)) __PYX_ERR(5, 5067, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_TRIMA", 0, 1, 2, i); __PYX_ERR(5, 5067, __pyx_L3_error) }
+      }
+    } else {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 5067, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 5067, __pyx_L3_error)
+        break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+    }
+    __pyx_v_real = ((PyArrayObject *)values[0]);
+    if (values[1]) {
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 5069, __pyx_L3_error)
+    } else {
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
+    }
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("stream_TRIMA", 0, 1, 2, __pyx_nargs); __PYX_ERR(5, 5067, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_TRIMA", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 5069, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_668stream_TRIMA(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_157CDLSTALLEDPATTERN, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 2376, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLSTALLEDPATTERN, __pyx_t_3) < 0) __PYX_ERR(2, 2376, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
+  __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_159CDLSTICKSANDWICH, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 2408, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLSTICKSANDWICH, __pyx_t_3) < 0) __PYX_ERR(2, 2408, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+static PyObject *__pyx_pf_5talib_7_ta_lib_668stream_TRIMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
+  npy_intp __pyx_v_length;
+  TA_RetCode __pyx_v_retCode;
+  double *__pyx_v_real_data;
+  int __pyx_v_outbegidx;
+  int __pyx_v_outnbelement;
+  double __pyx_v_outreal;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_TRIMA", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_161CDLTAKURI, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 2440, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLTAKURI, __pyx_t_3) < 0) __PYX_ERR(2, 2440, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 5088, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_163CDLTASUKIGAP, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 2472, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLTASUKIGAP, __pyx_t_3) < 0) __PYX_ERR(2, 2472, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real));
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_165CDLTHRUSTING, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 2504, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLTHRUSTING, __pyx_t_3) < 0) __PYX_ERR(2, 2504, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_167CDLTRISTAR, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 2536, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLTRISTAR, __pyx_t_3) < 0) __PYX_ERR(2, 2536, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_169CDLUNIQUE3RIVER, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 2568, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLUNIQUE3RIVER, __pyx_t_3) < 0) __PYX_ERR(2, 2568, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_v_retCode = TA_TRIMA((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_171CDLUPSIDEGAP2CROWS, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 2600, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLUPSIDEGAP2CROWS, __pyx_t_3) < 0) __PYX_ERR(2, 2600, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_TRIMA, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 5093, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_173CDLXSIDEGAP3METHODS, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 2632, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_CDLXSIDEGAP3METHODS, __pyx_t_3) < 0) __PYX_ERR(2, 2632, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 5094, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_175CEIL, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 2664, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_CEIL, __pyx_t_3) < 0) __PYX_ERR(2, 2664, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_177CMO, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 2693, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_CMO, __pyx_t_3) < 0) __PYX_ERR(2, 2693, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("talib._ta_lib.stream_TRIMA", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_real);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_179CORREL, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 2724, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_CORREL, __pyx_t_3) < 0) __PYX_ERR(2, 2724, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_181COS, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 2757, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_COS, __pyx_t_3) < 0) __PYX_ERR(2, 2757, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+/* Python wrapper */
+static PyObject *__pyx_pw_5talib_7_ta_lib_671stream_TRIX(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_670stream_TRIX, "stream_TRIX(ndarray real, int timeperiod=-0x80000000)\n\nTRIX(real[, timeperiod=?])\n\n1-day Rate-Of-Change (ROC) of a Triple Smooth EMA (Momentum Indicators)\n\nInputs:\n    real: (any ndarray)\nParameters:\n    timeperiod: 30\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_671stream_TRIX = {"stream_TRIX", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_671stream_TRIX, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_670stream_TRIX};
+static PyObject *__pyx_pw_5talib_7_ta_lib_671stream_TRIX(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_real = 0;
+  int __pyx_v_timeperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("stream_TRIX (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 5096, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 5096, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 5096, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_TRIX", 0) < (0)) __PYX_ERR(5, 5096, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_TRIX", 0, 1, 2, i); __PYX_ERR(5, 5096, __pyx_L3_error) }
+      }
+    } else {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 5096, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 5096, __pyx_L3_error)
+        break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+    }
+    __pyx_v_real = ((PyArrayObject *)values[0]);
+    if (values[1]) {
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 5098, __pyx_L3_error)
+    } else {
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
+    }
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("stream_TRIX", 0, 1, 2, __pyx_nargs); __PYX_ERR(5, 5096, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_TRIX", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 5098, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_670stream_TRIX(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_183COSH, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 2786, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_COSH, __pyx_t_3) < 0) __PYX_ERR(2, 2786, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
+  __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_185DEMA, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 2815, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_DEMA, __pyx_t_3) < 0) __PYX_ERR(2, 2815, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+static PyObject *__pyx_pf_5talib_7_ta_lib_670stream_TRIX(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
+  npy_intp __pyx_v_length;
+  TA_RetCode __pyx_v_retCode;
+  double *__pyx_v_real_data;
+  int __pyx_v_outbegidx;
+  int __pyx_v_outnbelement;
+  double __pyx_v_outreal;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_TRIX", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_187DIV, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 2846, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_DIV, __pyx_t_3) < 0) __PYX_ERR(2, 2846, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 5117, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_189DX, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 2877, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_DX, __pyx_t_3) < 0) __PYX_ERR(2, 2877, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real));
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_191EMA, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 2910, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_EMA, __pyx_t_3) < 0) __PYX_ERR(2, 2910, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_193EXP, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 2941, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_EXP, __pyx_t_3) < 0) __PYX_ERR(2, 2941, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_195FLOOR, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 2970, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_FLOOR, __pyx_t_3) < 0) __PYX_ERR(2, 2970, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_v_retCode = TA_TRIX((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_197HT_DCPERIOD, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 2999, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_HT_DCPERIOD, __pyx_t_3) < 0) __PYX_ERR(2, 2999, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_TRIX, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 5122, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_199HT_DCPHASE, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 3028, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_HT_DCPHASE, __pyx_t_3) < 0) __PYX_ERR(2, 3028, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 5123, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_201HT_PHASOR, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 3057, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_HT_PHASOR, __pyx_t_3) < 0) __PYX_ERR(2, 3057, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_203HT_SINE, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 3089, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_HT_SINE, __pyx_t_3) < 0) __PYX_ERR(2, 3089, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("talib._ta_lib.stream_TRIX", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_real);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_205HT_TRENDLINE, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 3121, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_HT_TRENDLINE, __pyx_t_3) < 0) __PYX_ERR(2, 3121, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_207HT_TRENDMODE, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 3150, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_HT_TRENDMODE, __pyx_t_3) < 0) __PYX_ERR(2, 3150, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+/* Python wrapper */
+static PyObject *__pyx_pw_5talib_7_ta_lib_673stream_TSF(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_672stream_TSF, "stream_TSF(ndarray real, int timeperiod=-0x80000000)\n\nTSF(real[, timeperiod=?])\n\nTime Series Forecast (Statistic Functions)\n\nInputs:\n    real: (any ndarray)\nParameters:\n    timeperiod: 14\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_673stream_TSF = {"stream_TSF", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_673stream_TSF, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_672stream_TSF};
+static PyObject *__pyx_pw_5talib_7_ta_lib_673stream_TSF(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_real = 0;
+  int __pyx_v_timeperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("stream_TSF (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 5125, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 5125, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 5125, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_TSF", 0) < (0)) __PYX_ERR(5, 5125, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_TSF", 0, 1, 2, i); __PYX_ERR(5, 5125, __pyx_L3_error) }
+      }
+    } else {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 5125, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 5125, __pyx_L3_error)
+        break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+    }
+    __pyx_v_real = ((PyArrayObject *)values[0]);
+    if (values[1]) {
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 5127, __pyx_L3_error)
+    } else {
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
+    }
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("stream_TSF", 0, 1, 2, __pyx_nargs); __PYX_ERR(5, 5125, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_TSF", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 5127, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_672stream_TSF(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_209KAMA, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 3179, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_KAMA, __pyx_t_3) < 0) __PYX_ERR(2, 3179, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
+  __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_211LINEARREG, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 3210, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LINEARREG, __pyx_t_3) < 0) __PYX_ERR(2, 3210, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+static PyObject *__pyx_pf_5talib_7_ta_lib_672stream_TSF(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
+  npy_intp __pyx_v_length;
+  TA_RetCode __pyx_v_retCode;
+  double *__pyx_v_real_data;
+  int __pyx_v_outbegidx;
+  int __pyx_v_outnbelement;
+  double __pyx_v_outreal;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_TSF", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_213LINEARREG_ANGLE, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 3241, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LINEARREG_ANGLE, __pyx_t_3) < 0) __PYX_ERR(2, 3241, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 5146, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_215LINEARREG_INTERCEPT, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 3272, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LINEARREG_INTERCEPT, __pyx_t_3) < 0) __PYX_ERR(2, 3272, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real));
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_217LINEARREG_SLOPE, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 3303, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LINEARREG_SLOPE, __pyx_t_3) < 0) __PYX_ERR(2, 3303, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_219LN, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 3334, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LN, __pyx_t_3) < 0) __PYX_ERR(2, 3334, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_221LOG10, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 3363, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_LOG10, __pyx_t_3) < 0) __PYX_ERR(2, 3363, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_v_retCode = TA_TSF((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_223MA, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 3392, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_MA, __pyx_t_3) < 0) __PYX_ERR(2, 3392, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_TSF, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 5151, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_225MACD, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 3424, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_MACD, __pyx_t_3) < 0) __PYX_ERR(2, 3424, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 5152, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_227MACDEXT, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 3463, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_MACDEXT, __pyx_t_3) < 0) __PYX_ERR(2, 3463, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_229MACDFIX, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 3505, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_MACDFIX, __pyx_t_3) < 0) __PYX_ERR(2, 3505, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("talib._ta_lib.stream_TSF", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_real);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_231MAMA, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 3542, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_MAMA, __pyx_t_3) < 0) __PYX_ERR(2, 3542, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_233MAVP, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 3577, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_MAVP, __pyx_t_3) < 0) __PYX_ERR(2, 3577, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+/* Python wrapper */
+static PyObject *__pyx_pw_5talib_7_ta_lib_675stream_TYPPRICE(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_674stream_TYPPRICE, "stream_TYPPRICE(ndarray high, ndarray low, ndarray close)\n\nTYPPRICE(high, low, close)\n\nTypical Price (Price Transform)\n\nInputs:\n    prices: ['high', 'low', 'close']\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_675stream_TYPPRICE = {"stream_TYPPRICE", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_675stream_TYPPRICE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_674stream_TYPPRICE};
+static PyObject *__pyx_pw_5talib_7_ta_lib_675stream_TYPPRICE(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_high = 0;
+  PyArrayObject *__pyx_v_low = 0;
+  PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[3] = {0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("stream_TYPPRICE (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 5154, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 5154, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 5154, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 5154, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_TYPPRICE", 0) < (0)) __PYX_ERR(5, 5154, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 3; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_TYPPRICE", 1, 3, 3, i); __PYX_ERR(5, 5154, __pyx_L3_error) }
+      }
+    } else if (unlikely(__pyx_nargs != 3)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 5154, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 5154, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 5154, __pyx_L3_error)
+    }
+    __pyx_v_high = ((PyArrayObject *)values[0]);
+    __pyx_v_low = ((PyArrayObject *)values[1]);
+    __pyx_v_close = ((PyArrayObject *)values[2]);
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("stream_TYPPRICE", 1, 3, 3, __pyx_nargs); __PYX_ERR(5, 5154, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_TYPPRICE", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 5156, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 5156, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 5156, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_674stream_TYPPRICE(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_235MAX, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 3612, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_MAX, __pyx_t_3) < 0) __PYX_ERR(2, 3612, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
+  __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_237MAXINDEX, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 3643, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_MAXINDEX, __pyx_t_3) < 0) __PYX_ERR(2, 3643, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+static PyObject *__pyx_pf_5talib_7_ta_lib_674stream_TYPPRICE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+  npy_intp __pyx_v_length;
+  TA_RetCode __pyx_v_retCode;
+  double *__pyx_v_high_data;
+  double *__pyx_v_low_data;
+  double *__pyx_v_close_data;
+  int __pyx_v_outbegidx;
+  int __pyx_v_outnbelement;
+  double __pyx_v_outreal;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  npy_intp __pyx_t_2;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_TYPPRICE", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_high);
+  __Pyx_INCREF((PyObject *)__pyx_v_low);
+  __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_239MEDPRICE, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 3674, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_MEDPRICE, __pyx_t_3) < 0) __PYX_ERR(2, 3674, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 5175, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_241MFI, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 3704, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_MFI, __pyx_t_3) < 0) __PYX_ERR(2, 3704, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high));
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_243MIDPOINT, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 3738, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_MIDPOINT, __pyx_t_3) < 0) __PYX_ERR(2, 3738, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_245MIDPRICE, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 3769, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_MIDPRICE, __pyx_t_3) < 0) __PYX_ERR(2, 3769, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_247MIN, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 3801, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_MIN, __pyx_t_3) < 0) __PYX_ERR(2, 3801, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_249MININDEX, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 3832, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_MININDEX, __pyx_t_3) < 0) __PYX_ERR(2, 3832, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_251MINMAX, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 3863, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_MINMAX, __pyx_t_3) < 0) __PYX_ERR(2, 3863, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_253MINMAXINDEX, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 3897, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_MINMAXINDEX, __pyx_t_3) < 0) __PYX_ERR(2, 3897, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_255MINUS_DI, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 3931, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_MINUS_DI, __pyx_t_3) < 0) __PYX_ERR(2, 3931, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 5177, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_257MINUS_DM, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 3964, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_MINUS_DM, __pyx_t_3) < 0) __PYX_ERR(2, 3964, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low));
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_259MOM, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 3996, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_MOM, __pyx_t_3) < 0) __PYX_ERR(2, 3996, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 5179, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_261MULT, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 4027, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_MULT, __pyx_t_3) < 0) __PYX_ERR(2, 4027, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close));
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_263NATR, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 4058, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_NATR, __pyx_t_3) < 0) __PYX_ERR(2, 4058, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 5181, __pyx_L1_error)
+  __pyx_v_length = __pyx_t_2;
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_265OBV, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 4091, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_OBV, __pyx_t_3) < 0) __PYX_ERR(2, 4091, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_267PLUS_DI, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 4122, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_PLUS_DI, __pyx_t_3) < 0) __PYX_ERR(2, 4122, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_v_retCode = TA_TYPPRICE((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_269PLUS_DM, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 4155, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_PLUS_DM, __pyx_t_3) < 0) __PYX_ERR(2, 4155, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_TYPPRICE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 5184, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_271PPO, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 4187, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_PPO, __pyx_t_3) < 0) __PYX_ERR(2, 4187, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 5185, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_273ROC, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 4220, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_ROC, __pyx_t_3) < 0) __PYX_ERR(2, 4220, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_275ROCP, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 4251, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_ROCP, __pyx_t_3) < 0) __PYX_ERR(2, 4251, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("talib._ta_lib.stream_TYPPRICE", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_high);
+  __Pyx_XDECREF((PyObject *)__pyx_v_low);
+  __Pyx_XDECREF((PyObject *)__pyx_v_close);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_277ROCR, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 4282, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_ROCR, __pyx_t_3) < 0) __PYX_ERR(2, 4282, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_279ROCR100, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 4313, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_ROCR100, __pyx_t_3) < 0) __PYX_ERR(2, 4313, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+/* Python wrapper */
+static PyObject *__pyx_pw_5talib_7_ta_lib_677stream_ULTOSC(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_676stream_ULTOSC, "stream_ULTOSC(ndarray high, ndarray low, ndarray close, int timeperiod1=-0x80000000, int timeperiod2=-0x80000000, int timeperiod3=-0x80000000)\n\nULTOSC(high, low, close[, timeperiod1=?, timeperiod2=?, timeperiod3=?])\n\nUltimate Oscillator (Momentum Indicators)\n\nInputs:\n    prices: ['high', 'low', 'close']\nParameters:\n    timeperiod1: 7\n    timeperiod2: 14\n    timeperiod3: 28\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_677stream_ULTOSC = {"stream_ULTOSC", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_677stream_ULTOSC, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_676stream_ULTOSC};
+static PyObject *__pyx_pw_5talib_7_ta_lib_677stream_ULTOSC(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_high = 0;
+  PyArrayObject *__pyx_v_low = 0;
+  PyArrayObject *__pyx_v_close = 0;
+  int __pyx_v_timeperiod1;
+  int __pyx_v_timeperiod2;
+  int __pyx_v_timeperiod3;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[6] = {0,0,0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("stream_ULTOSC (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,&__pyx_mstate_global->__pyx_n_u_timeperiod1,&__pyx_mstate_global->__pyx_n_u_timeperiod2,&__pyx_mstate_global->__pyx_n_u_timeperiod3,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 5187, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  6:
+        values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(5, 5187, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  5:
+        values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(5, 5187, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 5187, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 5187, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 5187, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 5187, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_ULTOSC", 0) < (0)) __PYX_ERR(5, 5187, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 3; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_ULTOSC", 0, 3, 6, i); __PYX_ERR(5, 5187, __pyx_L3_error) }
+      }
+    } else {
+      switch (__pyx_nargs) {
+        case  6:
+        values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(5, 5187, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  5:
+        values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(5, 5187, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 5187, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 5187, __pyx_L3_error)
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 5187, __pyx_L3_error)
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 5187, __pyx_L3_error)
+        break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+    }
+    __pyx_v_high = ((PyArrayObject *)values[0]);
+    __pyx_v_low = ((PyArrayObject *)values[1]);
+    __pyx_v_close = ((PyArrayObject *)values[2]);
+    if (values[3]) {
+      __pyx_v_timeperiod1 = __Pyx_PyLong_As_int(values[3]); if (unlikely((__pyx_v_timeperiod1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 5189, __pyx_L3_error)
+    } else {
+      __pyx_v_timeperiod1 = ((int)((int)-2147483648));
+    }
+    if (values[4]) {
+      __pyx_v_timeperiod2 = __Pyx_PyLong_As_int(values[4]); if (unlikely((__pyx_v_timeperiod2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 5189, __pyx_L3_error)
+    } else {
+      __pyx_v_timeperiod2 = ((int)((int)-2147483648));
+    }
+    if (values[5]) {
+      __pyx_v_timeperiod3 = __Pyx_PyLong_As_int(values[5]); if (unlikely((__pyx_v_timeperiod3 == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 5189, __pyx_L3_error)
+    } else {
+      __pyx_v_timeperiod3 = ((int)((int)-2147483648));
+    }
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("stream_ULTOSC", 0, 3, 6, __pyx_nargs); __PYX_ERR(5, 5187, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_ULTOSC", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 5189, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 5189, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 5189, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_676stream_ULTOSC(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_timeperiod1, __pyx_v_timeperiod2, __pyx_v_timeperiod3);
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_281RSI, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 4344, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_RSI, __pyx_t_3) < 0) __PYX_ERR(2, 4344, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
+  __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_283SAR, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 4375, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_SAR, __pyx_t_3) < 0) __PYX_ERR(2, 4375, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+static PyObject *__pyx_pf_5talib_7_ta_lib_676stream_ULTOSC(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod1, int __pyx_v_timeperiod2, int __pyx_v_timeperiod3) {
+  npy_intp __pyx_v_length;
+  TA_RetCode __pyx_v_retCode;
+  double *__pyx_v_high_data;
+  double *__pyx_v_low_data;
+  double *__pyx_v_close_data;
+  int __pyx_v_outbegidx;
+  int __pyx_v_outnbelement;
+  double __pyx_v_outreal;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  npy_intp __pyx_t_2;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_ULTOSC", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_high);
+  __Pyx_INCREF((PyObject *)__pyx_v_low);
+  __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_285SAREXT, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 4408, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_SAREXT, __pyx_t_3) < 0) __PYX_ERR(2, 4408, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 5212, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_287SIN, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 4447, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_SIN, __pyx_t_3) < 0) __PYX_ERR(2, 4447, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high));
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_289SINH, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 4476, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_SINH, __pyx_t_3) < 0) __PYX_ERR(2, 4476, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 5214, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_291SMA, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 4505, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_SMA, __pyx_t_3) < 0) __PYX_ERR(2, 4505, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low));
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_293SQRT, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 4536, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_SQRT, __pyx_t_3) < 0) __PYX_ERR(2, 4536, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 5216, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_295STDDEV, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 4565, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_STDDEV, __pyx_t_3) < 0) __PYX_ERR(2, 4565, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close));
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_297STOCH, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 4597, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_STOCH, __pyx_t_3) < 0) __PYX_ERR(2, 4597, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 5218, __pyx_L1_error)
+  __pyx_v_length = __pyx_t_2;
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_299STOCHF, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 4637, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_STOCHF, __pyx_t_3) < 0) __PYX_ERR(2, 4637, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_301STOCHRSI, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 4675, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_STOCHRSI, __pyx_t_3) < 0) __PYX_ERR(2, 4675, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_v_retCode = TA_ULTOSC((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, __pyx_v_timeperiod1, __pyx_v_timeperiod2, __pyx_v_timeperiod3, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_303SUB, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 4712, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_SUB, __pyx_t_3) < 0) __PYX_ERR(2, 4712, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_ULTOSC, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 5221, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_305SUM, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 4743, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_SUM, __pyx_t_3) < 0) __PYX_ERR(2, 4743, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 5222, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_307T3, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 4774, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_T3, __pyx_t_3) < 0) __PYX_ERR(2, 4774, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_309TAN, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 4806, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_TAN, __pyx_t_3) < 0) __PYX_ERR(2, 4806, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("talib._ta_lib.stream_ULTOSC", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_high);
+  __Pyx_XDECREF((PyObject *)__pyx_v_low);
+  __Pyx_XDECREF((PyObject *)__pyx_v_close);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_311TANH, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 4835, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_TANH, __pyx_t_3) < 0) __PYX_ERR(2, 4835, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_313TEMA, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 4864, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_TEMA, __pyx_t_3) < 0) __PYX_ERR(2, 4864, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+/* Python wrapper */
+static PyObject *__pyx_pw_5talib_7_ta_lib_679stream_VAR(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_678stream_VAR, "stream_VAR(ndarray real, int timeperiod=-0x80000000, double nbdev=-4e37)\n\nVAR(real[, timeperiod=?, nbdev=?])\n\nVariance (Statistic Functions)\n\nInputs:\n    real: (any ndarray)\nParameters:\n    timeperiod: 5\n    nbdev: 1.0\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_679stream_VAR = {"stream_VAR", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_679stream_VAR, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_678stream_VAR};
+static PyObject *__pyx_pw_5talib_7_ta_lib_679stream_VAR(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_real = 0;
+  int __pyx_v_timeperiod;
+  double __pyx_v_nbdev;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[3] = {0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("stream_VAR (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,&__pyx_mstate_global->__pyx_n_u_nbdev,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 5224, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 5224, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 5224, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 5224, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_VAR", 0) < (0)) __PYX_ERR(5, 5224, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_VAR", 0, 1, 3, i); __PYX_ERR(5, 5224, __pyx_L3_error) }
+      }
+    } else {
+      switch (__pyx_nargs) {
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 5224, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 5224, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 5224, __pyx_L3_error)
+        break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+    }
+    __pyx_v_real = ((PyArrayObject *)values[0]);
+    if (values[1]) {
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 5226, __pyx_L3_error)
+    } else {
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
+    }
+    if (values[2]) {
+      __pyx_v_nbdev = __Pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_nbdev == (double)-1) && PyErr_Occurred())) __PYX_ERR(5, 5226, __pyx_L3_error)
+    } else {
+      __pyx_v_nbdev = ((double)((double)-4e37));
+    }
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("stream_VAR", 0, 1, 3, __pyx_nargs); __PYX_ERR(5, 5224, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_VAR", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 5226, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_678stream_VAR(__pyx_self, __pyx_v_real, __pyx_v_timeperiod, __pyx_v_nbdev);
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_315TRANGE, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 4895, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_TRANGE, __pyx_t_3) < 0) __PYX_ERR(2, 4895, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
+  __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_317TRIMA, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 4926, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_TRIMA, __pyx_t_3) < 0) __PYX_ERR(2, 4926, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+static PyObject *__pyx_pf_5talib_7_ta_lib_678stream_VAR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod, double __pyx_v_nbdev) {
+  npy_intp __pyx_v_length;
+  TA_RetCode __pyx_v_retCode;
+  double *__pyx_v_real_data;
+  int __pyx_v_outbegidx;
+  int __pyx_v_outnbelement;
+  double __pyx_v_outreal;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_VAR", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_319TRIX, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 4957, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_TRIX, __pyx_t_3) < 0) __PYX_ERR(2, 4957, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 5246, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_321TSF, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 4988, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_TSF, __pyx_t_3) < 0) __PYX_ERR(2, 4988, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real));
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_323TYPPRICE, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 5019, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_TYPPRICE, __pyx_t_3) < 0) __PYX_ERR(2, 5019, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_325ULTOSC, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 5050, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_ULTOSC, __pyx_t_3) < 0) __PYX_ERR(2, 5050, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_327VAR, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 5085, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_VAR, __pyx_t_3) < 0) __PYX_ERR(2, 5085, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_v_retCode = TA_VAR((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, __pyx_v_nbdev, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_329WCLPRICE, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 5117, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_WCLPRICE, __pyx_t_3) < 0) __PYX_ERR(2, 5117, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_VAR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 5251, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_331WILLR, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 5148, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_WILLR, __pyx_t_3) < 0) __PYX_ERR(2, 5148, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 5252, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
 
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_333WMA, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 5181, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_WMA, __pyx_t_3) < 0) __PYX_ERR(2, 5181, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
-  __pyx_t_3 = PyList_New(158); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 5210, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __Pyx_INCREF(__pyx_n_s_ACOS);
-  __Pyx_GIVEREF(__pyx_n_s_ACOS);
-  PyList_SET_ITEM(__pyx_t_3, 0, __pyx_n_s_ACOS);
-  __Pyx_INCREF(__pyx_n_s_AD);
-  __Pyx_GIVEREF(__pyx_n_s_AD);
-  PyList_SET_ITEM(__pyx_t_3, 1, __pyx_n_s_AD);
-  __Pyx_INCREF(__pyx_n_s_ADD);
-  __Pyx_GIVEREF(__pyx_n_s_ADD);
-  PyList_SET_ITEM(__pyx_t_3, 2, __pyx_n_s_ADD);
-  __Pyx_INCREF(__pyx_n_s_ADOSC);
-  __Pyx_GIVEREF(__pyx_n_s_ADOSC);
-  PyList_SET_ITEM(__pyx_t_3, 3, __pyx_n_s_ADOSC);
-  __Pyx_INCREF(__pyx_n_s_ADX);
-  __Pyx_GIVEREF(__pyx_n_s_ADX);
-  PyList_SET_ITEM(__pyx_t_3, 4, __pyx_n_s_ADX);
-  __Pyx_INCREF(__pyx_n_s_ADXR);
-  __Pyx_GIVEREF(__pyx_n_s_ADXR);
-  PyList_SET_ITEM(__pyx_t_3, 5, __pyx_n_s_ADXR);
-  __Pyx_INCREF(__pyx_n_s_APO);
-  __Pyx_GIVEREF(__pyx_n_s_APO);
-  PyList_SET_ITEM(__pyx_t_3, 6, __pyx_n_s_APO);
-  __Pyx_INCREF(__pyx_n_s_AROON);
-  __Pyx_GIVEREF(__pyx_n_s_AROON);
-  PyList_SET_ITEM(__pyx_t_3, 7, __pyx_n_s_AROON);
-  __Pyx_INCREF(__pyx_n_s_AROONOSC);
-  __Pyx_GIVEREF(__pyx_n_s_AROONOSC);
-  PyList_SET_ITEM(__pyx_t_3, 8, __pyx_n_s_AROONOSC);
-  __Pyx_INCREF(__pyx_n_s_ASIN);
-  __Pyx_GIVEREF(__pyx_n_s_ASIN);
-  PyList_SET_ITEM(__pyx_t_3, 9, __pyx_n_s_ASIN);
-  __Pyx_INCREF(__pyx_n_s_ATAN);
-  __Pyx_GIVEREF(__pyx_n_s_ATAN);
-  PyList_SET_ITEM(__pyx_t_3, 10, __pyx_n_s_ATAN);
-  __Pyx_INCREF(__pyx_n_s_ATR);
-  __Pyx_GIVEREF(__pyx_n_s_ATR);
-  PyList_SET_ITEM(__pyx_t_3, 11, __pyx_n_s_ATR);
-  __Pyx_INCREF(__pyx_n_s_AVGPRICE);
-  __Pyx_GIVEREF(__pyx_n_s_AVGPRICE);
-  PyList_SET_ITEM(__pyx_t_3, 12, __pyx_n_s_AVGPRICE);
-  __Pyx_INCREF(__pyx_n_s_BBANDS);
-  __Pyx_GIVEREF(__pyx_n_s_BBANDS);
-  PyList_SET_ITEM(__pyx_t_3, 13, __pyx_n_s_BBANDS);
-  __Pyx_INCREF(__pyx_n_s_BETA);
-  __Pyx_GIVEREF(__pyx_n_s_BETA);
-  PyList_SET_ITEM(__pyx_t_3, 14, __pyx_n_s_BETA);
-  __Pyx_INCREF(__pyx_n_s_BOP);
-  __Pyx_GIVEREF(__pyx_n_s_BOP);
-  PyList_SET_ITEM(__pyx_t_3, 15, __pyx_n_s_BOP);
-  __Pyx_INCREF(__pyx_n_s_CCI);
-  __Pyx_GIVEREF(__pyx_n_s_CCI);
-  PyList_SET_ITEM(__pyx_t_3, 16, __pyx_n_s_CCI);
-  __Pyx_INCREF(__pyx_n_s_CDL2CROWS);
-  __Pyx_GIVEREF(__pyx_n_s_CDL2CROWS);
-  PyList_SET_ITEM(__pyx_t_3, 17, __pyx_n_s_CDL2CROWS);
-  __Pyx_INCREF(__pyx_n_s_CDL3BLACKCROWS);
-  __Pyx_GIVEREF(__pyx_n_s_CDL3BLACKCROWS);
-  PyList_SET_ITEM(__pyx_t_3, 18, __pyx_n_s_CDL3BLACKCROWS);
-  __Pyx_INCREF(__pyx_n_s_CDL3INSIDE);
-  __Pyx_GIVEREF(__pyx_n_s_CDL3INSIDE);
-  PyList_SET_ITEM(__pyx_t_3, 19, __pyx_n_s_CDL3INSIDE);
-  __Pyx_INCREF(__pyx_n_s_CDL3LINESTRIKE);
-  __Pyx_GIVEREF(__pyx_n_s_CDL3LINESTRIKE);
-  PyList_SET_ITEM(__pyx_t_3, 20, __pyx_n_s_CDL3LINESTRIKE);
-  __Pyx_INCREF(__pyx_n_s_CDL3OUTSIDE);
-  __Pyx_GIVEREF(__pyx_n_s_CDL3OUTSIDE);
-  PyList_SET_ITEM(__pyx_t_3, 21, __pyx_n_s_CDL3OUTSIDE);
-  __Pyx_INCREF(__pyx_n_s_CDL3STARSINSOUTH);
-  __Pyx_GIVEREF(__pyx_n_s_CDL3STARSINSOUTH);
-  PyList_SET_ITEM(__pyx_t_3, 22, __pyx_n_s_CDL3STARSINSOUTH);
-  __Pyx_INCREF(__pyx_n_s_CDL3WHITESOLDIERS);
-  __Pyx_GIVEREF(__pyx_n_s_CDL3WHITESOLDIERS);
-  PyList_SET_ITEM(__pyx_t_3, 23, __pyx_n_s_CDL3WHITESOLDIERS);
-  __Pyx_INCREF(__pyx_n_s_CDLABANDONEDBABY);
-  __Pyx_GIVEREF(__pyx_n_s_CDLABANDONEDBABY);
-  PyList_SET_ITEM(__pyx_t_3, 24, __pyx_n_s_CDLABANDONEDBABY);
-  __Pyx_INCREF(__pyx_n_s_CDLADVANCEBLOCK);
-  __Pyx_GIVEREF(__pyx_n_s_CDLADVANCEBLOCK);
-  PyList_SET_ITEM(__pyx_t_3, 25, __pyx_n_s_CDLADVANCEBLOCK);
-  __Pyx_INCREF(__pyx_n_s_CDLBELTHOLD);
-  __Pyx_GIVEREF(__pyx_n_s_CDLBELTHOLD);
-  PyList_SET_ITEM(__pyx_t_3, 26, __pyx_n_s_CDLBELTHOLD);
-  __Pyx_INCREF(__pyx_n_s_CDLBREAKAWAY);
-  __Pyx_GIVEREF(__pyx_n_s_CDLBREAKAWAY);
-  PyList_SET_ITEM(__pyx_t_3, 27, __pyx_n_s_CDLBREAKAWAY);
-  __Pyx_INCREF(__pyx_n_s_CDLCLOSINGMARUBOZU);
-  __Pyx_GIVEREF(__pyx_n_s_CDLCLOSINGMARUBOZU);
-  PyList_SET_ITEM(__pyx_t_3, 28, __pyx_n_s_CDLCLOSINGMARUBOZU);
-  __Pyx_INCREF(__pyx_n_s_CDLCONCEALBABYSWALL);
-  __Pyx_GIVEREF(__pyx_n_s_CDLCONCEALBABYSWALL);
-  PyList_SET_ITEM(__pyx_t_3, 29, __pyx_n_s_CDLCONCEALBABYSWALL);
-  __Pyx_INCREF(__pyx_n_s_CDLCOUNTERATTACK);
-  __Pyx_GIVEREF(__pyx_n_s_CDLCOUNTERATTACK);
-  PyList_SET_ITEM(__pyx_t_3, 30, __pyx_n_s_CDLCOUNTERATTACK);
-  __Pyx_INCREF(__pyx_n_s_CDLDARKCLOUDCOVER);
-  __Pyx_GIVEREF(__pyx_n_s_CDLDARKCLOUDCOVER);
-  PyList_SET_ITEM(__pyx_t_3, 31, __pyx_n_s_CDLDARKCLOUDCOVER);
-  __Pyx_INCREF(__pyx_n_s_CDLDOJI);
-  __Pyx_GIVEREF(__pyx_n_s_CDLDOJI);
-  PyList_SET_ITEM(__pyx_t_3, 32, __pyx_n_s_CDLDOJI);
-  __Pyx_INCREF(__pyx_n_s_CDLDOJISTAR);
-  __Pyx_GIVEREF(__pyx_n_s_CDLDOJISTAR);
-  PyList_SET_ITEM(__pyx_t_3, 33, __pyx_n_s_CDLDOJISTAR);
-  __Pyx_INCREF(__pyx_n_s_CDLDRAGONFLYDOJI);
-  __Pyx_GIVEREF(__pyx_n_s_CDLDRAGONFLYDOJI);
-  PyList_SET_ITEM(__pyx_t_3, 34, __pyx_n_s_CDLDRAGONFLYDOJI);
-  __Pyx_INCREF(__pyx_n_s_CDLENGULFING);
-  __Pyx_GIVEREF(__pyx_n_s_CDLENGULFING);
-  PyList_SET_ITEM(__pyx_t_3, 35, __pyx_n_s_CDLENGULFING);
-  __Pyx_INCREF(__pyx_n_s_CDLEVENINGDOJISTAR);
-  __Pyx_GIVEREF(__pyx_n_s_CDLEVENINGDOJISTAR);
-  PyList_SET_ITEM(__pyx_t_3, 36, __pyx_n_s_CDLEVENINGDOJISTAR);
-  __Pyx_INCREF(__pyx_n_s_CDLEVENINGSTAR);
-  __Pyx_GIVEREF(__pyx_n_s_CDLEVENINGSTAR);
-  PyList_SET_ITEM(__pyx_t_3, 37, __pyx_n_s_CDLEVENINGSTAR);
-  __Pyx_INCREF(__pyx_n_s_CDLGAPSIDESIDEWHITE);
-  __Pyx_GIVEREF(__pyx_n_s_CDLGAPSIDESIDEWHITE);
-  PyList_SET_ITEM(__pyx_t_3, 38, __pyx_n_s_CDLGAPSIDESIDEWHITE);
-  __Pyx_INCREF(__pyx_n_s_CDLGRAVESTONEDOJI);
-  __Pyx_GIVEREF(__pyx_n_s_CDLGRAVESTONEDOJI);
-  PyList_SET_ITEM(__pyx_t_3, 39, __pyx_n_s_CDLGRAVESTONEDOJI);
-  __Pyx_INCREF(__pyx_n_s_CDLHAMMER);
-  __Pyx_GIVEREF(__pyx_n_s_CDLHAMMER);
-  PyList_SET_ITEM(__pyx_t_3, 40, __pyx_n_s_CDLHAMMER);
-  __Pyx_INCREF(__pyx_n_s_CDLHANGINGMAN);
-  __Pyx_GIVEREF(__pyx_n_s_CDLHANGINGMAN);
-  PyList_SET_ITEM(__pyx_t_3, 41, __pyx_n_s_CDLHANGINGMAN);
-  __Pyx_INCREF(__pyx_n_s_CDLHARAMI);
-  __Pyx_GIVEREF(__pyx_n_s_CDLHARAMI);
-  PyList_SET_ITEM(__pyx_t_3, 42, __pyx_n_s_CDLHARAMI);
-  __Pyx_INCREF(__pyx_n_s_CDLHARAMICROSS);
-  __Pyx_GIVEREF(__pyx_n_s_CDLHARAMICROSS);
-  PyList_SET_ITEM(__pyx_t_3, 43, __pyx_n_s_CDLHARAMICROSS);
-  __Pyx_INCREF(__pyx_n_s_CDLHIGHWAVE);
-  __Pyx_GIVEREF(__pyx_n_s_CDLHIGHWAVE);
-  PyList_SET_ITEM(__pyx_t_3, 44, __pyx_n_s_CDLHIGHWAVE);
-  __Pyx_INCREF(__pyx_n_s_CDLHIKKAKE);
-  __Pyx_GIVEREF(__pyx_n_s_CDLHIKKAKE);
-  PyList_SET_ITEM(__pyx_t_3, 45, __pyx_n_s_CDLHIKKAKE);
-  __Pyx_INCREF(__pyx_n_s_CDLHIKKAKEMOD);
-  __Pyx_GIVEREF(__pyx_n_s_CDLHIKKAKEMOD);
-  PyList_SET_ITEM(__pyx_t_3, 46, __pyx_n_s_CDLHIKKAKEMOD);
-  __Pyx_INCREF(__pyx_n_s_CDLHOMINGPIGEON);
-  __Pyx_GIVEREF(__pyx_n_s_CDLHOMINGPIGEON);
-  PyList_SET_ITEM(__pyx_t_3, 47, __pyx_n_s_CDLHOMINGPIGEON);
-  __Pyx_INCREF(__pyx_n_s_CDLIDENTICAL3CROWS);
-  __Pyx_GIVEREF(__pyx_n_s_CDLIDENTICAL3CROWS);
-  PyList_SET_ITEM(__pyx_t_3, 48, __pyx_n_s_CDLIDENTICAL3CROWS);
-  __Pyx_INCREF(__pyx_n_s_CDLINNECK);
-  __Pyx_GIVEREF(__pyx_n_s_CDLINNECK);
-  PyList_SET_ITEM(__pyx_t_3, 49, __pyx_n_s_CDLINNECK);
-  __Pyx_INCREF(__pyx_n_s_CDLINVERTEDHAMMER);
-  __Pyx_GIVEREF(__pyx_n_s_CDLINVERTEDHAMMER);
-  PyList_SET_ITEM(__pyx_t_3, 50, __pyx_n_s_CDLINVERTEDHAMMER);
-  __Pyx_INCREF(__pyx_n_s_CDLKICKING);
-  __Pyx_GIVEREF(__pyx_n_s_CDLKICKING);
-  PyList_SET_ITEM(__pyx_t_3, 51, __pyx_n_s_CDLKICKING);
-  __Pyx_INCREF(__pyx_n_s_CDLKICKINGBYLENGTH);
-  __Pyx_GIVEREF(__pyx_n_s_CDLKICKINGBYLENGTH);
-  PyList_SET_ITEM(__pyx_t_3, 52, __pyx_n_s_CDLKICKINGBYLENGTH);
-  __Pyx_INCREF(__pyx_n_s_CDLLADDERBOTTOM);
-  __Pyx_GIVEREF(__pyx_n_s_CDLLADDERBOTTOM);
-  PyList_SET_ITEM(__pyx_t_3, 53, __pyx_n_s_CDLLADDERBOTTOM);
-  __Pyx_INCREF(__pyx_n_s_CDLLONGLEGGEDDOJI);
-  __Pyx_GIVEREF(__pyx_n_s_CDLLONGLEGGEDDOJI);
-  PyList_SET_ITEM(__pyx_t_3, 54, __pyx_n_s_CDLLONGLEGGEDDOJI);
-  __Pyx_INCREF(__pyx_n_s_CDLLONGLINE);
-  __Pyx_GIVEREF(__pyx_n_s_CDLLONGLINE);
-  PyList_SET_ITEM(__pyx_t_3, 55, __pyx_n_s_CDLLONGLINE);
-  __Pyx_INCREF(__pyx_n_s_CDLMARUBOZU);
-  __Pyx_GIVEREF(__pyx_n_s_CDLMARUBOZU);
-  PyList_SET_ITEM(__pyx_t_3, 56, __pyx_n_s_CDLMARUBOZU);
-  __Pyx_INCREF(__pyx_n_s_CDLMATCHINGLOW);
-  __Pyx_GIVEREF(__pyx_n_s_CDLMATCHINGLOW);
-  PyList_SET_ITEM(__pyx_t_3, 57, __pyx_n_s_CDLMATCHINGLOW);
-  __Pyx_INCREF(__pyx_n_s_CDLMATHOLD);
-  __Pyx_GIVEREF(__pyx_n_s_CDLMATHOLD);
-  PyList_SET_ITEM(__pyx_t_3, 58, __pyx_n_s_CDLMATHOLD);
-  __Pyx_INCREF(__pyx_n_s_CDLMORNINGDOJISTAR);
-  __Pyx_GIVEREF(__pyx_n_s_CDLMORNINGDOJISTAR);
-  PyList_SET_ITEM(__pyx_t_3, 59, __pyx_n_s_CDLMORNINGDOJISTAR);
-  __Pyx_INCREF(__pyx_n_s_CDLMORNINGSTAR);
-  __Pyx_GIVEREF(__pyx_n_s_CDLMORNINGSTAR);
-  PyList_SET_ITEM(__pyx_t_3, 60, __pyx_n_s_CDLMORNINGSTAR);
-  __Pyx_INCREF(__pyx_n_s_CDLONNECK);
-  __Pyx_GIVEREF(__pyx_n_s_CDLONNECK);
-  PyList_SET_ITEM(__pyx_t_3, 61, __pyx_n_s_CDLONNECK);
-  __Pyx_INCREF(__pyx_n_s_CDLPIERCING);
-  __Pyx_GIVEREF(__pyx_n_s_CDLPIERCING);
-  PyList_SET_ITEM(__pyx_t_3, 62, __pyx_n_s_CDLPIERCING);
-  __Pyx_INCREF(__pyx_n_s_CDLRICKSHAWMAN);
-  __Pyx_GIVEREF(__pyx_n_s_CDLRICKSHAWMAN);
-  PyList_SET_ITEM(__pyx_t_3, 63, __pyx_n_s_CDLRICKSHAWMAN);
-  __Pyx_INCREF(__pyx_n_s_CDLRISEFALL3METHODS);
-  __Pyx_GIVEREF(__pyx_n_s_CDLRISEFALL3METHODS);
-  PyList_SET_ITEM(__pyx_t_3, 64, __pyx_n_s_CDLRISEFALL3METHODS);
-  __Pyx_INCREF(__pyx_n_s_CDLSEPARATINGLINES);
-  __Pyx_GIVEREF(__pyx_n_s_CDLSEPARATINGLINES);
-  PyList_SET_ITEM(__pyx_t_3, 65, __pyx_n_s_CDLSEPARATINGLINES);
-  __Pyx_INCREF(__pyx_n_s_CDLSHOOTINGSTAR);
-  __Pyx_GIVEREF(__pyx_n_s_CDLSHOOTINGSTAR);
-  PyList_SET_ITEM(__pyx_t_3, 66, __pyx_n_s_CDLSHOOTINGSTAR);
-  __Pyx_INCREF(__pyx_n_s_CDLSHORTLINE);
-  __Pyx_GIVEREF(__pyx_n_s_CDLSHORTLINE);
-  PyList_SET_ITEM(__pyx_t_3, 67, __pyx_n_s_CDLSHORTLINE);
-  __Pyx_INCREF(__pyx_n_s_CDLSPINNINGTOP);
-  __Pyx_GIVEREF(__pyx_n_s_CDLSPINNINGTOP);
-  PyList_SET_ITEM(__pyx_t_3, 68, __pyx_n_s_CDLSPINNINGTOP);
-  __Pyx_INCREF(__pyx_n_s_CDLSTALLEDPATTERN);
-  __Pyx_GIVEREF(__pyx_n_s_CDLSTALLEDPATTERN);
-  PyList_SET_ITEM(__pyx_t_3, 69, __pyx_n_s_CDLSTALLEDPATTERN);
-  __Pyx_INCREF(__pyx_n_s_CDLSTICKSANDWICH);
-  __Pyx_GIVEREF(__pyx_n_s_CDLSTICKSANDWICH);
-  PyList_SET_ITEM(__pyx_t_3, 70, __pyx_n_s_CDLSTICKSANDWICH);
-  __Pyx_INCREF(__pyx_n_s_CDLTAKURI);
-  __Pyx_GIVEREF(__pyx_n_s_CDLTAKURI);
-  PyList_SET_ITEM(__pyx_t_3, 71, __pyx_n_s_CDLTAKURI);
-  __Pyx_INCREF(__pyx_n_s_CDLTASUKIGAP);
-  __Pyx_GIVEREF(__pyx_n_s_CDLTASUKIGAP);
-  PyList_SET_ITEM(__pyx_t_3, 72, __pyx_n_s_CDLTASUKIGAP);
-  __Pyx_INCREF(__pyx_n_s_CDLTHRUSTING);
-  __Pyx_GIVEREF(__pyx_n_s_CDLTHRUSTING);
-  PyList_SET_ITEM(__pyx_t_3, 73, __pyx_n_s_CDLTHRUSTING);
-  __Pyx_INCREF(__pyx_n_s_CDLTRISTAR);
-  __Pyx_GIVEREF(__pyx_n_s_CDLTRISTAR);
-  PyList_SET_ITEM(__pyx_t_3, 74, __pyx_n_s_CDLTRISTAR);
-  __Pyx_INCREF(__pyx_n_s_CDLUNIQUE3RIVER);
-  __Pyx_GIVEREF(__pyx_n_s_CDLUNIQUE3RIVER);
-  PyList_SET_ITEM(__pyx_t_3, 75, __pyx_n_s_CDLUNIQUE3RIVER);
-  __Pyx_INCREF(__pyx_n_s_CDLUPSIDEGAP2CROWS);
-  __Pyx_GIVEREF(__pyx_n_s_CDLUPSIDEGAP2CROWS);
-  PyList_SET_ITEM(__pyx_t_3, 76, __pyx_n_s_CDLUPSIDEGAP2CROWS);
-  __Pyx_INCREF(__pyx_n_s_CDLXSIDEGAP3METHODS);
-  __Pyx_GIVEREF(__pyx_n_s_CDLXSIDEGAP3METHODS);
-  PyList_SET_ITEM(__pyx_t_3, 77, __pyx_n_s_CDLXSIDEGAP3METHODS);
-  __Pyx_INCREF(__pyx_n_s_CEIL);
-  __Pyx_GIVEREF(__pyx_n_s_CEIL);
-  PyList_SET_ITEM(__pyx_t_3, 78, __pyx_n_s_CEIL);
-  __Pyx_INCREF(__pyx_n_s_CMO);
-  __Pyx_GIVEREF(__pyx_n_s_CMO);
-  PyList_SET_ITEM(__pyx_t_3, 79, __pyx_n_s_CMO);
-  __Pyx_INCREF(__pyx_n_s_CORREL);
-  __Pyx_GIVEREF(__pyx_n_s_CORREL);
-  PyList_SET_ITEM(__pyx_t_3, 80, __pyx_n_s_CORREL);
-  __Pyx_INCREF(__pyx_n_s_COS);
-  __Pyx_GIVEREF(__pyx_n_s_COS);
-  PyList_SET_ITEM(__pyx_t_3, 81, __pyx_n_s_COS);
-  __Pyx_INCREF(__pyx_n_s_COSH);
-  __Pyx_GIVEREF(__pyx_n_s_COSH);
-  PyList_SET_ITEM(__pyx_t_3, 82, __pyx_n_s_COSH);
-  __Pyx_INCREF(__pyx_n_s_DEMA);
-  __Pyx_GIVEREF(__pyx_n_s_DEMA);
-  PyList_SET_ITEM(__pyx_t_3, 83, __pyx_n_s_DEMA);
-  __Pyx_INCREF(__pyx_n_s_DIV);
-  __Pyx_GIVEREF(__pyx_n_s_DIV);
-  PyList_SET_ITEM(__pyx_t_3, 84, __pyx_n_s_DIV);
-  __Pyx_INCREF(__pyx_n_s_DX);
-  __Pyx_GIVEREF(__pyx_n_s_DX);
-  PyList_SET_ITEM(__pyx_t_3, 85, __pyx_n_s_DX);
-  __Pyx_INCREF(__pyx_n_s_EMA);
-  __Pyx_GIVEREF(__pyx_n_s_EMA);
-  PyList_SET_ITEM(__pyx_t_3, 86, __pyx_n_s_EMA);
-  __Pyx_INCREF(__pyx_n_s_EXP);
-  __Pyx_GIVEREF(__pyx_n_s_EXP);
-  PyList_SET_ITEM(__pyx_t_3, 87, __pyx_n_s_EXP);
-  __Pyx_INCREF(__pyx_n_s_FLOOR);
-  __Pyx_GIVEREF(__pyx_n_s_FLOOR);
-  PyList_SET_ITEM(__pyx_t_3, 88, __pyx_n_s_FLOOR);
-  __Pyx_INCREF(__pyx_n_s_HT_DCPERIOD);
-  __Pyx_GIVEREF(__pyx_n_s_HT_DCPERIOD);
-  PyList_SET_ITEM(__pyx_t_3, 89, __pyx_n_s_HT_DCPERIOD);
-  __Pyx_INCREF(__pyx_n_s_HT_DCPHASE);
-  __Pyx_GIVEREF(__pyx_n_s_HT_DCPHASE);
-  PyList_SET_ITEM(__pyx_t_3, 90, __pyx_n_s_HT_DCPHASE);
-  __Pyx_INCREF(__pyx_n_s_HT_PHASOR);
-  __Pyx_GIVEREF(__pyx_n_s_HT_PHASOR);
-  PyList_SET_ITEM(__pyx_t_3, 91, __pyx_n_s_HT_PHASOR);
-  __Pyx_INCREF(__pyx_n_s_HT_SINE);
-  __Pyx_GIVEREF(__pyx_n_s_HT_SINE);
-  PyList_SET_ITEM(__pyx_t_3, 92, __pyx_n_s_HT_SINE);
-  __Pyx_INCREF(__pyx_n_s_HT_TRENDLINE);
-  __Pyx_GIVEREF(__pyx_n_s_HT_TRENDLINE);
-  PyList_SET_ITEM(__pyx_t_3, 93, __pyx_n_s_HT_TRENDLINE);
-  __Pyx_INCREF(__pyx_n_s_HT_TRENDMODE);
-  __Pyx_GIVEREF(__pyx_n_s_HT_TRENDMODE);
-  PyList_SET_ITEM(__pyx_t_3, 94, __pyx_n_s_HT_TRENDMODE);
-  __Pyx_INCREF(__pyx_n_s_KAMA);
-  __Pyx_GIVEREF(__pyx_n_s_KAMA);
-  PyList_SET_ITEM(__pyx_t_3, 95, __pyx_n_s_KAMA);
-  __Pyx_INCREF(__pyx_n_s_LINEARREG);
-  __Pyx_GIVEREF(__pyx_n_s_LINEARREG);
-  PyList_SET_ITEM(__pyx_t_3, 96, __pyx_n_s_LINEARREG);
-  __Pyx_INCREF(__pyx_n_s_LINEARREG_ANGLE);
-  __Pyx_GIVEREF(__pyx_n_s_LINEARREG_ANGLE);
-  PyList_SET_ITEM(__pyx_t_3, 97, __pyx_n_s_LINEARREG_ANGLE);
-  __Pyx_INCREF(__pyx_n_s_LINEARREG_INTERCEPT);
-  __Pyx_GIVEREF(__pyx_n_s_LINEARREG_INTERCEPT);
-  PyList_SET_ITEM(__pyx_t_3, 98, __pyx_n_s_LINEARREG_INTERCEPT);
-  __Pyx_INCREF(__pyx_n_s_LINEARREG_SLOPE);
-  __Pyx_GIVEREF(__pyx_n_s_LINEARREG_SLOPE);
-  PyList_SET_ITEM(__pyx_t_3, 99, __pyx_n_s_LINEARREG_SLOPE);
-  __Pyx_INCREF(__pyx_n_s_LN);
-  __Pyx_GIVEREF(__pyx_n_s_LN);
-  PyList_SET_ITEM(__pyx_t_3, 100, __pyx_n_s_LN);
-  __Pyx_INCREF(__pyx_n_s_LOG10);
-  __Pyx_GIVEREF(__pyx_n_s_LOG10);
-  PyList_SET_ITEM(__pyx_t_3, 101, __pyx_n_s_LOG10);
-  __Pyx_INCREF(__pyx_n_s_MA);
-  __Pyx_GIVEREF(__pyx_n_s_MA);
-  PyList_SET_ITEM(__pyx_t_3, 102, __pyx_n_s_MA);
-  __Pyx_INCREF(__pyx_n_s_MACD);
-  __Pyx_GIVEREF(__pyx_n_s_MACD);
-  PyList_SET_ITEM(__pyx_t_3, 103, __pyx_n_s_MACD);
-  __Pyx_INCREF(__pyx_n_s_MACDEXT);
-  __Pyx_GIVEREF(__pyx_n_s_MACDEXT);
-  PyList_SET_ITEM(__pyx_t_3, 104, __pyx_n_s_MACDEXT);
-  __Pyx_INCREF(__pyx_n_s_MACDFIX);
-  __Pyx_GIVEREF(__pyx_n_s_MACDFIX);
-  PyList_SET_ITEM(__pyx_t_3, 105, __pyx_n_s_MACDFIX);
-  __Pyx_INCREF(__pyx_n_s_MAMA);
-  __Pyx_GIVEREF(__pyx_n_s_MAMA);
-  PyList_SET_ITEM(__pyx_t_3, 106, __pyx_n_s_MAMA);
-  __Pyx_INCREF(__pyx_n_s_MAVP);
-  __Pyx_GIVEREF(__pyx_n_s_MAVP);
-  PyList_SET_ITEM(__pyx_t_3, 107, __pyx_n_s_MAVP);
-  __Pyx_INCREF(__pyx_n_s_MAX);
-  __Pyx_GIVEREF(__pyx_n_s_MAX);
-  PyList_SET_ITEM(__pyx_t_3, 108, __pyx_n_s_MAX);
-  __Pyx_INCREF(__pyx_n_s_MAXINDEX);
-  __Pyx_GIVEREF(__pyx_n_s_MAXINDEX);
-  PyList_SET_ITEM(__pyx_t_3, 109, __pyx_n_s_MAXINDEX);
-  __Pyx_INCREF(__pyx_n_s_MEDPRICE);
-  __Pyx_GIVEREF(__pyx_n_s_MEDPRICE);
-  PyList_SET_ITEM(__pyx_t_3, 110, __pyx_n_s_MEDPRICE);
-  __Pyx_INCREF(__pyx_n_s_MFI);
-  __Pyx_GIVEREF(__pyx_n_s_MFI);
-  PyList_SET_ITEM(__pyx_t_3, 111, __pyx_n_s_MFI);
-  __Pyx_INCREF(__pyx_n_s_MIDPOINT);
-  __Pyx_GIVEREF(__pyx_n_s_MIDPOINT);
-  PyList_SET_ITEM(__pyx_t_3, 112, __pyx_n_s_MIDPOINT);
-  __Pyx_INCREF(__pyx_n_s_MIDPRICE);
-  __Pyx_GIVEREF(__pyx_n_s_MIDPRICE);
-  PyList_SET_ITEM(__pyx_t_3, 113, __pyx_n_s_MIDPRICE);
-  __Pyx_INCREF(__pyx_n_s_MIN);
-  __Pyx_GIVEREF(__pyx_n_s_MIN);
-  PyList_SET_ITEM(__pyx_t_3, 114, __pyx_n_s_MIN);
-  __Pyx_INCREF(__pyx_n_s_MININDEX);
-  __Pyx_GIVEREF(__pyx_n_s_MININDEX);
-  PyList_SET_ITEM(__pyx_t_3, 115, __pyx_n_s_MININDEX);
-  __Pyx_INCREF(__pyx_n_s_MINMAX);
-  __Pyx_GIVEREF(__pyx_n_s_MINMAX);
-  PyList_SET_ITEM(__pyx_t_3, 116, __pyx_n_s_MINMAX);
-  __Pyx_INCREF(__pyx_n_s_MINMAXINDEX);
-  __Pyx_GIVEREF(__pyx_n_s_MINMAXINDEX);
-  PyList_SET_ITEM(__pyx_t_3, 117, __pyx_n_s_MINMAXINDEX);
-  __Pyx_INCREF(__pyx_n_s_MINUS_DI);
-  __Pyx_GIVEREF(__pyx_n_s_MINUS_DI);
-  PyList_SET_ITEM(__pyx_t_3, 118, __pyx_n_s_MINUS_DI);
-  __Pyx_INCREF(__pyx_n_s_MINUS_DM);
-  __Pyx_GIVEREF(__pyx_n_s_MINUS_DM);
-  PyList_SET_ITEM(__pyx_t_3, 119, __pyx_n_s_MINUS_DM);
-  __Pyx_INCREF(__pyx_n_s_MOM);
-  __Pyx_GIVEREF(__pyx_n_s_MOM);
-  PyList_SET_ITEM(__pyx_t_3, 120, __pyx_n_s_MOM);
-  __Pyx_INCREF(__pyx_n_s_MULT);
-  __Pyx_GIVEREF(__pyx_n_s_MULT);
-  PyList_SET_ITEM(__pyx_t_3, 121, __pyx_n_s_MULT);
-  __Pyx_INCREF(__pyx_n_s_NATR);
-  __Pyx_GIVEREF(__pyx_n_s_NATR);
-  PyList_SET_ITEM(__pyx_t_3, 122, __pyx_n_s_NATR);
-  __Pyx_INCREF(__pyx_n_s_OBV);
-  __Pyx_GIVEREF(__pyx_n_s_OBV);
-  PyList_SET_ITEM(__pyx_t_3, 123, __pyx_n_s_OBV);
-  __Pyx_INCREF(__pyx_n_s_PLUS_DI);
-  __Pyx_GIVEREF(__pyx_n_s_PLUS_DI);
-  PyList_SET_ITEM(__pyx_t_3, 124, __pyx_n_s_PLUS_DI);
-  __Pyx_INCREF(__pyx_n_s_PLUS_DM);
-  __Pyx_GIVEREF(__pyx_n_s_PLUS_DM);
-  PyList_SET_ITEM(__pyx_t_3, 125, __pyx_n_s_PLUS_DM);
-  __Pyx_INCREF(__pyx_n_s_PPO);
-  __Pyx_GIVEREF(__pyx_n_s_PPO);
-  PyList_SET_ITEM(__pyx_t_3, 126, __pyx_n_s_PPO);
-  __Pyx_INCREF(__pyx_n_s_ROC);
-  __Pyx_GIVEREF(__pyx_n_s_ROC);
-  PyList_SET_ITEM(__pyx_t_3, 127, __pyx_n_s_ROC);
-  __Pyx_INCREF(__pyx_n_s_ROCP);
-  __Pyx_GIVEREF(__pyx_n_s_ROCP);
-  PyList_SET_ITEM(__pyx_t_3, 128, __pyx_n_s_ROCP);
-  __Pyx_INCREF(__pyx_n_s_ROCR);
-  __Pyx_GIVEREF(__pyx_n_s_ROCR);
-  PyList_SET_ITEM(__pyx_t_3, 129, __pyx_n_s_ROCR);
-  __Pyx_INCREF(__pyx_n_s_ROCR100);
-  __Pyx_GIVEREF(__pyx_n_s_ROCR100);
-  PyList_SET_ITEM(__pyx_t_3, 130, __pyx_n_s_ROCR100);
-  __Pyx_INCREF(__pyx_n_s_RSI);
-  __Pyx_GIVEREF(__pyx_n_s_RSI);
-  PyList_SET_ITEM(__pyx_t_3, 131, __pyx_n_s_RSI);
-  __Pyx_INCREF(__pyx_n_s_SAR);
-  __Pyx_GIVEREF(__pyx_n_s_SAR);
-  PyList_SET_ITEM(__pyx_t_3, 132, __pyx_n_s_SAR);
-  __Pyx_INCREF(__pyx_n_s_SAREXT);
-  __Pyx_GIVEREF(__pyx_n_s_SAREXT);
-  PyList_SET_ITEM(__pyx_t_3, 133, __pyx_n_s_SAREXT);
-  __Pyx_INCREF(__pyx_n_s_SIN);
-  __Pyx_GIVEREF(__pyx_n_s_SIN);
-  PyList_SET_ITEM(__pyx_t_3, 134, __pyx_n_s_SIN);
-  __Pyx_INCREF(__pyx_n_s_SINH);
-  __Pyx_GIVEREF(__pyx_n_s_SINH);
-  PyList_SET_ITEM(__pyx_t_3, 135, __pyx_n_s_SINH);
-  __Pyx_INCREF(__pyx_n_s_SMA);
-  __Pyx_GIVEREF(__pyx_n_s_SMA);
-  PyList_SET_ITEM(__pyx_t_3, 136, __pyx_n_s_SMA);
-  __Pyx_INCREF(__pyx_n_s_SQRT);
-  __Pyx_GIVEREF(__pyx_n_s_SQRT);
-  PyList_SET_ITEM(__pyx_t_3, 137, __pyx_n_s_SQRT);
-  __Pyx_INCREF(__pyx_n_s_STDDEV);
-  __Pyx_GIVEREF(__pyx_n_s_STDDEV);
-  PyList_SET_ITEM(__pyx_t_3, 138, __pyx_n_s_STDDEV);
-  __Pyx_INCREF(__pyx_n_s_STOCH);
-  __Pyx_GIVEREF(__pyx_n_s_STOCH);
-  PyList_SET_ITEM(__pyx_t_3, 139, __pyx_n_s_STOCH);
-  __Pyx_INCREF(__pyx_n_s_STOCHF);
-  __Pyx_GIVEREF(__pyx_n_s_STOCHF);
-  PyList_SET_ITEM(__pyx_t_3, 140, __pyx_n_s_STOCHF);
-  __Pyx_INCREF(__pyx_n_s_STOCHRSI);
-  __Pyx_GIVEREF(__pyx_n_s_STOCHRSI);
-  PyList_SET_ITEM(__pyx_t_3, 141, __pyx_n_s_STOCHRSI);
-  __Pyx_INCREF(__pyx_n_s_SUB);
-  __Pyx_GIVEREF(__pyx_n_s_SUB);
-  PyList_SET_ITEM(__pyx_t_3, 142, __pyx_n_s_SUB);
-  __Pyx_INCREF(__pyx_n_s_SUM);
-  __Pyx_GIVEREF(__pyx_n_s_SUM);
-  PyList_SET_ITEM(__pyx_t_3, 143, __pyx_n_s_SUM);
-  __Pyx_INCREF(__pyx_n_s_T3);
-  __Pyx_GIVEREF(__pyx_n_s_T3);
-  PyList_SET_ITEM(__pyx_t_3, 144, __pyx_n_s_T3);
-  __Pyx_INCREF(__pyx_n_s_TAN);
-  __Pyx_GIVEREF(__pyx_n_s_TAN);
-  PyList_SET_ITEM(__pyx_t_3, 145, __pyx_n_s_TAN);
-  __Pyx_INCREF(__pyx_n_s_TANH);
-  __Pyx_GIVEREF(__pyx_n_s_TANH);
-  PyList_SET_ITEM(__pyx_t_3, 146, __pyx_n_s_TANH);
-  __Pyx_INCREF(__pyx_n_s_TEMA);
-  __Pyx_GIVEREF(__pyx_n_s_TEMA);
-  PyList_SET_ITEM(__pyx_t_3, 147, __pyx_n_s_TEMA);
-  __Pyx_INCREF(__pyx_n_s_TRANGE);
-  __Pyx_GIVEREF(__pyx_n_s_TRANGE);
-  PyList_SET_ITEM(__pyx_t_3, 148, __pyx_n_s_TRANGE);
-  __Pyx_INCREF(__pyx_n_s_TRIMA);
-  __Pyx_GIVEREF(__pyx_n_s_TRIMA);
-  PyList_SET_ITEM(__pyx_t_3, 149, __pyx_n_s_TRIMA);
-  __Pyx_INCREF(__pyx_n_s_TRIX);
-  __Pyx_GIVEREF(__pyx_n_s_TRIX);
-  PyList_SET_ITEM(__pyx_t_3, 150, __pyx_n_s_TRIX);
-  __Pyx_INCREF(__pyx_n_s_TSF);
-  __Pyx_GIVEREF(__pyx_n_s_TSF);
-  PyList_SET_ITEM(__pyx_t_3, 151, __pyx_n_s_TSF);
-  __Pyx_INCREF(__pyx_n_s_TYPPRICE);
-  __Pyx_GIVEREF(__pyx_n_s_TYPPRICE);
-  PyList_SET_ITEM(__pyx_t_3, 152, __pyx_n_s_TYPPRICE);
-  __Pyx_INCREF(__pyx_n_s_ULTOSC);
-  __Pyx_GIVEREF(__pyx_n_s_ULTOSC);
-  PyList_SET_ITEM(__pyx_t_3, 153, __pyx_n_s_ULTOSC);
-  __Pyx_INCREF(__pyx_n_s_VAR);
-  __Pyx_GIVEREF(__pyx_n_s_VAR);
-  PyList_SET_ITEM(__pyx_t_3, 154, __pyx_n_s_VAR);
-  __Pyx_INCREF(__pyx_n_s_WCLPRICE);
-  __Pyx_GIVEREF(__pyx_n_s_WCLPRICE);
-  PyList_SET_ITEM(__pyx_t_3, 155, __pyx_n_s_WCLPRICE);
-  __Pyx_INCREF(__pyx_n_s_WILLR);
-  __Pyx_GIVEREF(__pyx_n_s_WILLR);
-  PyList_SET_ITEM(__pyx_t_3, 156, __pyx_n_s_WILLR);
-  __Pyx_INCREF(__pyx_n_s_WMA);
-  __Pyx_GIVEREF(__pyx_n_s_WMA);
-  PyList_SET_ITEM(__pyx_t_3, 157, __pyx_n_s_WMA);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_TA_FUNCTION_NAMES, __pyx_t_3) < 0) __PYX_ERR(2, 5210, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("talib._ta_lib.stream_VAR", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_real);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
 
-  __pyx_t_3 = __Pyx_Import(__pyx_n_s_math, 0, -1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 4, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_math, __pyx_t_3) < 0) __PYX_ERR(1, 4, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
+/* Python wrapper */
+static PyObject *__pyx_pw_5talib_7_ta_lib_681stream_WCLPRICE(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_680stream_WCLPRICE, "stream_WCLPRICE(ndarray high, ndarray low, ndarray close)\n\nWCLPRICE(high, low, close)\n\nWeighted Close Price (Price Transform)\n\nInputs:\n    prices: ['high', 'low', 'close']\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_681stream_WCLPRICE = {"stream_WCLPRICE", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_681stream_WCLPRICE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_680stream_WCLPRICE};
+static PyObject *__pyx_pw_5talib_7_ta_lib_681stream_WCLPRICE(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_high = 0;
+  PyArrayObject *__pyx_v_low = 0;
+  PyArrayObject *__pyx_v_close = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[3] = {0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("stream_WCLPRICE (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    __Pyx_PyThreadState_declare
-    __Pyx_PyThreadState_assign
-    __Pyx_ExceptionSave(&__pyx_t_21, &__pyx_t_22, &__pyx_t_23);
-    __Pyx_XGOTREF(__pyx_t_21);
-    __Pyx_XGOTREF(__pyx_t_22);
-    __Pyx_XGOTREF(__pyx_t_23);
-    /*try:*/ {
-
-      __pyx_t_3 = PyList_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 6, __pyx_L10_error)
-      __Pyx_GOTREF(__pyx_t_3);
-      __Pyx_INCREF(__pyx_n_s_OrderedDict);
-      __Pyx_GIVEREF(__pyx_n_s_OrderedDict);
-      PyList_SET_ITEM(__pyx_t_3, 0, __pyx_n_s_OrderedDict);
-      __pyx_t_2 = __Pyx_Import(__pyx_n_s_collections, __pyx_t_3, -1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 6, __pyx_L10_error)
-      __Pyx_GOTREF(__pyx_t_2);
-      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-      __pyx_t_3 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_OrderedDict); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 6, __pyx_L10_error)
-      __Pyx_GOTREF(__pyx_t_3);
-      if (PyDict_SetItem(__pyx_d, __pyx_n_s_OrderedDict, __pyx_t_3) < 0) __PYX_ERR(1, 6, __pyx_L10_error)
-      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-
-    }
-    __Pyx_XDECREF(__pyx_t_21); __pyx_t_21 = 0;
-    __Pyx_XDECREF(__pyx_t_22); __pyx_t_22 = 0;
-    __Pyx_XDECREF(__pyx_t_23); __pyx_t_23 = 0;
-    goto __pyx_L15_try_end;
-    __pyx_L10_error:;
-    __Pyx_XDECREF(__pyx_t_18); __pyx_t_18 = 0;
-    __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
-    __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
-    __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
-    __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
-    __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
-    __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
-    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
-    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
-    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
-    __Pyx_XDECREF(__pyx_t_17); __pyx_t_17 = 0;
-    __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0;
-    __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
-    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
-    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
-    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
-
-    __pyx_t_20 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_ImportError);
-    if (__pyx_t_20) {
-      __Pyx_AddTraceback("talib._ta_lib", __pyx_clineno, __pyx_lineno, __pyx_filename);
-      if (__Pyx_GetException(&__pyx_t_2, &__pyx_t_3, &__pyx_t_1) < 0) __PYX_ERR(1, 7, __pyx_L12_except_error)
-      __Pyx_GOTREF(__pyx_t_2);
-      __Pyx_GOTREF(__pyx_t_3);
-      __Pyx_GOTREF(__pyx_t_1);
-
-      __pyx_t_13 = PyList_New(1); if (unlikely(!__pyx_t_13)) __PYX_ERR(1, 8, __pyx_L12_except_error)
-      __Pyx_GOTREF(__pyx_t_13);
-      __Pyx_INCREF(__pyx_n_s_OrderedDict);
-      __Pyx_GIVEREF(__pyx_n_s_OrderedDict);
-      PyList_SET_ITEM(__pyx_t_13, 0, __pyx_n_s_OrderedDict);
-      __pyx_t_16 = __Pyx_Import(__pyx_n_s_ordereddict, __pyx_t_13, -1); if (unlikely(!__pyx_t_16)) __PYX_ERR(1, 8, __pyx_L12_except_error)
-      __Pyx_GOTREF(__pyx_t_16);
-      __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
-      __pyx_t_13 = __Pyx_ImportFrom(__pyx_t_16, __pyx_n_s_OrderedDict); if (unlikely(!__pyx_t_13)) __PYX_ERR(1, 8, __pyx_L12_except_error)
-      __Pyx_GOTREF(__pyx_t_13);
-      if (PyDict_SetItem(__pyx_d, __pyx_n_s_OrderedDict, __pyx_t_13) < 0) __PYX_ERR(1, 8, __pyx_L12_except_error)
-      __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
-      __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
-      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
-      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
-      __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
-      goto __pyx_L11_exception_handled;
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 5254, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 5254, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 5254, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 5254, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_WCLPRICE", 0) < (0)) __PYX_ERR(5, 5254, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 3; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_WCLPRICE", 1, 3, 3, i); __PYX_ERR(5, 5254, __pyx_L3_error) }
+      }
+    } else if (unlikely(__pyx_nargs != 3)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 5254, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 5254, __pyx_L3_error)
+      values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 5254, __pyx_L3_error)
     }
-    goto __pyx_L12_except_error;
-    __pyx_L12_except_error:;
+    __pyx_v_high = ((PyArrayObject *)values[0]);
+    __pyx_v_low = ((PyArrayObject *)values[1]);
+    __pyx_v_close = ((PyArrayObject *)values[2]);
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("stream_WCLPRICE", 1, 3, 3, __pyx_nargs); __PYX_ERR(5, 5254, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("talib._ta_lib.stream_WCLPRICE", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 5256, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 5256, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 5256, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_680stream_WCLPRICE(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close);
 
-    __Pyx_XGIVEREF(__pyx_t_21);
-    __Pyx_XGIVEREF(__pyx_t_22);
-    __Pyx_XGIVEREF(__pyx_t_23);
-    __Pyx_ExceptionReset(__pyx_t_21, __pyx_t_22, __pyx_t_23);
-    goto __pyx_L1_error;
-    __pyx_L11_exception_handled:;
-    __Pyx_XGIVEREF(__pyx_t_21);
-    __Pyx_XGIVEREF(__pyx_t_22);
-    __Pyx_XGIVEREF(__pyx_t_23);
-    __Pyx_ExceptionReset(__pyx_t_21, __pyx_t_22, __pyx_t_23);
-    __pyx_L15_try_end:;
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
+  __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
   }
+  __pyx_L7_cleaned_up:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_5talib_7_ta_lib_680stream_WCLPRICE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close) {
+  npy_intp __pyx_v_length;
+  TA_RetCode __pyx_v_retCode;
+  double *__pyx_v_high_data;
+  double *__pyx_v_low_data;
+  double *__pyx_v_close_data;
+  int __pyx_v_outbegidx;
+  int __pyx_v_outnbelement;
+  double __pyx_v_outreal;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  npy_intp __pyx_t_2;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_WCLPRICE", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_high);
+  __Pyx_INCREF((PyObject *)__pyx_v_low);
+  __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = __Pyx_Import(__pyx_n_s_numpy, 0, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 10, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 5275, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_numpy, __pyx_t_1) < 0) __PYX_ERR(1, 10, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
 
-  __pyx_t_1 = __Pyx_Import(__pyx_n_s_sys, 0, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 11, __pyx_L1_error)
+  __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high));
+
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 5277, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_sys, __pyx_t_1) < 0) __PYX_ERR(1, 11, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
 
-  __pyx_t_1 = __Pyx_PyDict_NewPresized(5); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 18, __pyx_L1_error)
+  __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low));
+
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 5279, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_open, Py_None) < 0) __PYX_ERR(1, 18, __pyx_L1_error)
+  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
 
-  if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_high, Py_None) < 0) __PYX_ERR(1, 18, __pyx_L1_error)
+  __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close));
 
-  if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_low, Py_None) < 0) __PYX_ERR(1, 18, __pyx_L1_error)
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 5281, __pyx_L1_error)
+  __pyx_v_length = __pyx_t_2;
 
-  if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_close, Py_None) < 0) __PYX_ERR(1, 18, __pyx_L1_error)
+  __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
 
-  if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_volume, Py_None) < 0) __PYX_ERR(1, 18, __pyx_L1_error)
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_INPUT_ARRAYS_DEFAULTS, __pyx_t_1) < 0) __PYX_ERR(1, 18, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v_retCode = TA_WCLPRICE((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
 
-  __pyx_t_1 = __Pyx_PyDict_NewPresized(4); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 26, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_WCLPRICE, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 5284, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_price, __pyx_n_s_close) < 0) __PYX_ERR(1, 26, __pyx_L1_error)
-  if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_price0, __pyx_n_s_high) < 0) __PYX_ERR(1, 26, __pyx_L1_error)
-  if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_price1, __pyx_n_s_low) < 0) __PYX_ERR(1, 26, __pyx_L1_error)
-  if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_periods, __pyx_n_s_periods) < 0) __PYX_ERR(1, 26, __pyx_L1_error)
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_INPUT_PRICE_SERIES_DEFAULTS, __pyx_t_1) < 0) __PYX_ERR(1, 26, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
-  {
-    __Pyx_PyThreadState_declare
-    __Pyx_PyThreadState_assign
-    __Pyx_ExceptionSave(&__pyx_t_23, &__pyx_t_22, &__pyx_t_21);
-    __Pyx_XGOTREF(__pyx_t_23);
-    __Pyx_XGOTREF(__pyx_t_22);
-    __Pyx_XGOTREF(__pyx_t_21);
-    /*try:*/ {
-
-      __pyx_t_1 = __Pyx_Import(__pyx_n_s_pandas, 0, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 34, __pyx_L18_error)
-      __Pyx_GOTREF(__pyx_t_1);
-      if (PyDict_SetItem(__pyx_d, __pyx_n_s_pandas, __pyx_t_1) < 0) __PYX_ERR(1, 34, __pyx_L18_error)
-      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 5285, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
 
-      __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_pandas); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 35, __pyx_L18_error)
-      __Pyx_GOTREF(__pyx_t_1);
-      __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_DataFrame); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 35, __pyx_L18_error)
-      __Pyx_GOTREF(__pyx_t_3);
-      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-      __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 35, __pyx_L18_error)
-      __Pyx_GOTREF(__pyx_t_1);
-      __Pyx_INCREF(((PyObject *)(&PyDict_Type)));
-      __Pyx_GIVEREF(((PyObject *)(&PyDict_Type)));
-      PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)(&PyDict_Type)));
-      __Pyx_GIVEREF(__pyx_t_3);
-      PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_3);
-      __pyx_t_3 = 0;
-      if (PyDict_SetItem(__pyx_d, __pyx_n_s_INPUT_ARRAYS_TYPES, __pyx_t_1) < 0) __PYX_ERR(1, 35, __pyx_L18_error)
-      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
-      __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_pandas); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 36, __pyx_L18_error)
-      __Pyx_GOTREF(__pyx_t_1);
-      __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_Series); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 36, __pyx_L18_error)
-      __Pyx_GOTREF(__pyx_t_3);
-      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-      __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 36, __pyx_L18_error)
-      __Pyx_GOTREF(__pyx_t_1);
-      __Pyx_INCREF(((PyObject *)__pyx_ptype_5numpy_ndarray));
-      __Pyx_GIVEREF(((PyObject *)__pyx_ptype_5numpy_ndarray));
-      PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_ptype_5numpy_ndarray));
-      __Pyx_GIVEREF(__pyx_t_3);
-      PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_3);
-      __pyx_t_3 = 0;
-      if (PyDict_SetItem(__pyx_d, __pyx_n_s_ARRAY_TYPES, __pyx_t_1) < 0) __PYX_ERR(1, 36, __pyx_L18_error)
-      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("talib._ta_lib.stream_WCLPRICE", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_high);
+  __Pyx_XDECREF((PyObject *)__pyx_v_low);
+  __Pyx_XDECREF((PyObject *)__pyx_v_close);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
 
-      __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_pandas); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 37, __pyx_L18_error)
-      __Pyx_GOTREF(__pyx_t_1);
-      __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_DataFrame); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 37, __pyx_L18_error)
-      __Pyx_GOTREF(__pyx_t_3);
-      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-      if (PyDict_SetItem(__pyx_d, __pyx_n_s_PANDAS_DATAFRAME, __pyx_t_3) < 0) __PYX_ERR(1, 37, __pyx_L18_error)
-      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-
-      __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_pandas); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 38, __pyx_L18_error)
-      __Pyx_GOTREF(__pyx_t_3);
-      __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_Series); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 38, __pyx_L18_error)
-      __Pyx_GOTREF(__pyx_t_1);
-      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-      if (PyDict_SetItem(__pyx_d, __pyx_n_s_PANDAS_SERIES, __pyx_t_1) < 0) __PYX_ERR(1, 38, __pyx_L18_error)
-      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
+/* Python wrapper */
+static PyObject *__pyx_pw_5talib_7_ta_lib_683stream_WILLR(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_682stream_WILLR, "stream_WILLR(ndarray high, ndarray low, ndarray close, int timeperiod=-0x80000000)\n\nWILLR(high, low, close[, timeperiod=?])\n\nWilliams' %R (Momentum Indicators)\n\nInputs:\n    prices: ['high', 'low', 'close']\nParameters:\n    timeperiod: 14\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_683stream_WILLR = {"stream_WILLR", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_683stream_WILLR, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_682stream_WILLR};
+static PyObject *__pyx_pw_5talib_7_ta_lib_683stream_WILLR(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_high = 0;
+  PyArrayObject *__pyx_v_low = 0;
+  PyArrayObject *__pyx_v_close = 0;
+  int __pyx_v_timeperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[4] = {0,0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("stream_WILLR (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_high,&__pyx_mstate_global->__pyx_n_u_low,&__pyx_mstate_global->__pyx_n_u_close,&__pyx_mstate_global->__pyx_n_u_timeperiod,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 5287, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 5287, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 5287, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 5287, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 5287, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_WILLR", 0) < (0)) __PYX_ERR(5, 5287, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 3; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_WILLR", 0, 3, 4, i); __PYX_ERR(5, 5287, __pyx_L3_error) }
+      }
+    } else {
+      switch (__pyx_nargs) {
+        case  4:
+        values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(5, 5287, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  3:
+        values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(5, 5287, __pyx_L3_error)
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 5287, __pyx_L3_error)
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 5287, __pyx_L3_error)
+        break;
+        default: goto __pyx_L5_argtuple_error;
+      }
     }
-    __Pyx_XDECREF(__pyx_t_23); __pyx_t_23 = 0;
-    __Pyx_XDECREF(__pyx_t_22); __pyx_t_22 = 0;
-    __Pyx_XDECREF(__pyx_t_21); __pyx_t_21 = 0;
-    goto __pyx_L23_try_end;
-    __pyx_L18_error:;
-    __Pyx_XDECREF(__pyx_t_18); __pyx_t_18 = 0;
-    __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
-    __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
-    __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
-    __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
-    __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
-    __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
-    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
-    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
-    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
-    __Pyx_XDECREF(__pyx_t_17); __pyx_t_17 = 0;
-    __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
-    __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0;
-    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
-    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
-    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
-
-    __pyx_t_20 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_ImportError);
-    if (__pyx_t_20) {
-      __Pyx_AddTraceback("talib._ta_lib", __pyx_clineno, __pyx_lineno, __pyx_filename);
-      if (__Pyx_GetException(&__pyx_t_1, &__pyx_t_3, &__pyx_t_2) < 0) __PYX_ERR(1, 39, __pyx_L20_except_error)
-      __Pyx_GOTREF(__pyx_t_1);
-      __Pyx_GOTREF(__pyx_t_3);
-      __Pyx_GOTREF(__pyx_t_2);
-
-      __pyx_t_16 = PyTuple_New(1); if (unlikely(!__pyx_t_16)) __PYX_ERR(1, 40, __pyx_L20_except_error)
-      __Pyx_GOTREF(__pyx_t_16);
-      __Pyx_INCREF(((PyObject *)(&PyDict_Type)));
-      __Pyx_GIVEREF(((PyObject *)(&PyDict_Type)));
-      PyTuple_SET_ITEM(__pyx_t_16, 0, ((PyObject *)(&PyDict_Type)));
-      if (PyDict_SetItem(__pyx_d, __pyx_n_s_INPUT_ARRAYS_TYPES, __pyx_t_16) < 0) __PYX_ERR(1, 40, __pyx_L20_except_error)
-      __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
-
-      __pyx_t_16 = PyTuple_New(1); if (unlikely(!__pyx_t_16)) __PYX_ERR(1, 41, __pyx_L20_except_error)
-      __Pyx_GOTREF(__pyx_t_16);
-      __Pyx_INCREF(((PyObject *)__pyx_ptype_5numpy_ndarray));
-      __Pyx_GIVEREF(((PyObject *)__pyx_ptype_5numpy_ndarray));
-      PyTuple_SET_ITEM(__pyx_t_16, 0, ((PyObject *)__pyx_ptype_5numpy_ndarray));
-      if (PyDict_SetItem(__pyx_d, __pyx_n_s_ARRAY_TYPES, __pyx_t_16) < 0) __PYX_ERR(1, 41, __pyx_L20_except_error)
-      __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
-
-      if (PyDict_SetItem(__pyx_d, __pyx_n_s_PANDAS_DATAFRAME, Py_None) < 0) __PYX_ERR(1, 42, __pyx_L20_except_error)
-
-      if (PyDict_SetItem(__pyx_d, __pyx_n_s_PANDAS_SERIES, Py_None) < 0) __PYX_ERR(1, 43, __pyx_L20_except_error)
-      __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
-      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
-      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
-      goto __pyx_L19_exception_handled;
+    __pyx_v_high = ((PyArrayObject *)values[0]);
+    __pyx_v_low = ((PyArrayObject *)values[1]);
+    __pyx_v_close = ((PyArrayObject *)values[2]);
+    if (values[3]) {
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[3]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 5289, __pyx_L3_error)
+    } else {
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
     }
-    goto __pyx_L20_except_error;
-    __pyx_L20_except_error:;
-
-    __Pyx_XGIVEREF(__pyx_t_23);
-    __Pyx_XGIVEREF(__pyx_t_22);
-    __Pyx_XGIVEREF(__pyx_t_21);
-    __Pyx_ExceptionReset(__pyx_t_23, __pyx_t_22, __pyx_t_21);
-    goto __pyx_L1_error;
-    __pyx_L19_exception_handled:;
-    __Pyx_XGIVEREF(__pyx_t_23);
-    __Pyx_XGIVEREF(__pyx_t_22);
-    __Pyx_XGIVEREF(__pyx_t_21);
-    __Pyx_ExceptionReset(__pyx_t_23, __pyx_t_22, __pyx_t_21);
-    __pyx_L23_try_end:;
   }
-
-  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_sys); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 45, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_version); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 45, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __pyx_t_2 = PyObject_RichCompare(__pyx_t_3, __pyx_kp_s_3, Py_GE); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 45, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __pyx_t_24 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_24 < 0)) __PYX_ERR(1, 45, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  if (__pyx_t_24) {
-
-    __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_335str2bytes, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 47, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_2);
-    if (PyDict_SetItem(__pyx_d, __pyx_n_s_str2bytes, __pyx_t_2) < 0) __PYX_ERR(1, 47, __pyx_L1_error)
-    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-
-    __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_337bytes2str, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 50, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_2);
-    if (PyDict_SetItem(__pyx_d, __pyx_n_s_bytes2str, __pyx_t_2) < 0) __PYX_ERR(1, 50, __pyx_L1_error)
-    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-
-    goto __pyx_L26;
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("stream_WILLR", 0, 3, 4, __pyx_nargs); __PYX_ERR(5, 5287, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
   }
+  __Pyx_AddTraceback("talib._ta_lib.stream_WILLR", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_high), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "high", 0))) __PYX_ERR(5, 5289, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_low), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "low", 0))) __PYX_ERR(5, 5289, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_close), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "close", 0))) __PYX_ERR(5, 5289, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_682stream_WILLR(__pyx_self, __pyx_v_high, __pyx_v_low, __pyx_v_close, __pyx_v_timeperiod);
 
-  /*else*/ {
-    __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_339str2bytes, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 55, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_2);
-    if (PyDict_SetItem(__pyx_d, __pyx_n_s_str2bytes, __pyx_t_2) < 0) __PYX_ERR(1, 55, __pyx_L1_error)
-    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-
-    __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_341bytes2str, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 58, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_2);
-    if (PyDict_SetItem(__pyx_d, __pyx_n_s_bytes2str, __pyx_t_2) < 0) __PYX_ERR(1, 58, __pyx_L1_error)
-    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
   }
-  __pyx_L26:;
+  goto __pyx_L7_cleaned_up;
+  __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
 
-  __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_tuple__369); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 61, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_tuple__369, __pyx_n_s_Function, __pyx_n_s_Function, (PyObject *) NULL, __pyx_n_s_talib__ta_lib, __pyx_kp_s_This_is_a_pythonic_wrapper_arou); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 61, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
+static PyObject *__pyx_pf_5talib_7_ta_lib_682stream_WILLR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_high, PyArrayObject *__pyx_v_low, PyArrayObject *__pyx_v_close, int __pyx_v_timeperiod) {
+  npy_intp __pyx_v_length;
+  TA_RetCode __pyx_v_retCode;
+  double *__pyx_v_high_data;
+  double *__pyx_v_low_data;
+  double *__pyx_v_close_data;
+  int __pyx_v_outbegidx;
+  int __pyx_v_outnbelement;
+  double __pyx_v_outreal;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  npy_intp __pyx_t_2;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_WILLR", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_high);
+  __Pyx_INCREF((PyObject *)__pyx_v_low);
+  __Pyx_INCREF((PyObject *)__pyx_v_close);
 
-  __pyx_t_1 = __Pyx_CyFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_8Function_1__init__, 0, __pyx_n_s_Function___init, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__371)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 90, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 5310, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_init, __pyx_t_1) < 0) __PYX_ERR(1, 90, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF_SET(__pyx_v_high, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
 
-  __pyx_t_1 = __Pyx_CyFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_8Function_3__initialize_function_info, 0, __pyx_n_s_Function___initialize_function_i, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__373)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 109, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_Function__initialize_function_i, __pyx_t_1) < 0) __PYX_ERR(1, 109, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v_high_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high));
 
-  __pyx_t_1 = __Pyx_CyFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_8Function_5info, 0, __pyx_n_s_Function_info, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__375)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 139, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_low)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 5312, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_low, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
 
-  __pyx_t_16 = __Pyx_PyObject_CallOneArg(__pyx_builtin_property, __pyx_t_1); if (unlikely(!__pyx_t_16)) __PYX_ERR(1, 138, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_16);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_info, __pyx_t_16) < 0) __PYX_ERR(1, 139, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
-
-  __pyx_t_16 = __Pyx_CyFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_8Function_7function_flags, 0, __pyx_n_s_Function_function_flags, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__377)); if (unlikely(!__pyx_t_16)) __PYX_ERR(1, 146, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_16);
-
-  __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_builtin_property, __pyx_t_16); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 145, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
-  if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_function_flags, __pyx_t_1) < 0) __PYX_ERR(1, 146, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v_low_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low));
 
-  __pyx_t_1 = __Pyx_CyFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_8Function_9output_flags, 0, __pyx_n_s_Function_output_flags, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__379)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 153, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_close)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 5314, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF_SET(__pyx_v_close, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
 
-  __pyx_t_16 = __Pyx_PyObject_CallOneArg(__pyx_builtin_property, __pyx_t_1); if (unlikely(!__pyx_t_16)) __PYX_ERR(1, 152, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_16);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_output_flags, __pyx_t_16) < 0) __PYX_ERR(1, 153, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
-
-  __pyx_t_16 = __Pyx_CyFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_8Function_11get_input_names, 0, __pyx_n_s_Function_get_input_names, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__381)); if (unlikely(!__pyx_t_16)) __PYX_ERR(1, 159, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_16);
-  if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_get_input_names, __pyx_t_16) < 0) __PYX_ERR(1, 159, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
+  __pyx_v_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close));
 
-  __pyx_t_16 = __Pyx_CyFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_8Function_13set_input_names, 0, __pyx_n_s_Function_set_input_names, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__383)); if (unlikely(!__pyx_t_16)) __PYX_ERR(1, 169, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_16);
-  if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_set_input_names, __pyx_t_16) < 0) __PYX_ERR(1, 169, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
+  __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length3(__pyx_v_high, __pyx_v_low, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1))) __PYX_ERR(5, 5316, __pyx_L1_error)
+  __pyx_v_length = __pyx_t_2;
 
-  __pyx_t_16 = PyObject_GetItem(__pyx_t_3, __pyx_n_s_get_input_names);
-  if (unlikely(!__pyx_t_16)) {
-    PyErr_Clear();
-    __Pyx_GetModuleGlobalName(__pyx_t_16, __pyx_n_s_get_input_names);
-  }
-  if (unlikely(!__pyx_t_16)) __PYX_ERR(1, 178, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_16);
-  __pyx_t_1 = PyObject_GetItem(__pyx_t_3, __pyx_n_s_set_input_names);
-  if (unlikely(!__pyx_t_1)) {
-    PyErr_Clear();
-    __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_set_input_names);
-  }
-  if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 178, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_13 = PyTuple_New(2); if (unlikely(!__pyx_t_13)) __PYX_ERR(1, 178, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_13);
-  __Pyx_GIVEREF(__pyx_t_16);
-  PyTuple_SET_ITEM(__pyx_t_13, 0, __pyx_t_16);
-  __Pyx_GIVEREF(__pyx_t_1);
-  PyTuple_SET_ITEM(__pyx_t_13, 1, __pyx_t_1);
-  __pyx_t_16 = 0;
-  __pyx_t_1 = 0;
-  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_property, __pyx_t_13, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 178, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
-  if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_input_names, __pyx_t_1) < 0) __PYX_ERR(1, 178, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
 
-  __pyx_t_1 = __Pyx_CyFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_8Function_15get_input_arrays, 0, __pyx_n_s_Function_get_input_arrays, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__385)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 180, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_get_input_arrays, __pyx_t_1) < 0) __PYX_ERR(1, 180, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v_retCode = TA_WILLR((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_high_data, __pyx_v_low_data, __pyx_v_close_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
 
-  __pyx_t_1 = __Pyx_CyFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_8Function_17set_input_arrays, 0, __pyx_n_s_Function_set_input_arrays, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__387)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 186, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_WILLR, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 5319, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_set_input_arrays, __pyx_t_1) < 0) __PYX_ERR(1, 186, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
-  __pyx_t_1 = PyObject_GetItem(__pyx_t_3, __pyx_n_s_get_input_arrays);
-  if (unlikely(!__pyx_t_1)) {
-    PyErr_Clear();
-    __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_get_input_arrays);
-  }
-  if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 227, __pyx_L1_error)
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 5320, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_13 = PyObject_GetItem(__pyx_t_3, __pyx_n_s_set_input_arrays);
-  if (unlikely(!__pyx_t_13)) {
-    PyErr_Clear();
-    __Pyx_GetModuleGlobalName(__pyx_t_13, __pyx_n_s_set_input_arrays);
-  }
-  if (unlikely(!__pyx_t_13)) __PYX_ERR(1, 227, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_13);
-  __pyx_t_16 = PyTuple_New(2); if (unlikely(!__pyx_t_16)) __PYX_ERR(1, 227, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_16);
-  __Pyx_GIVEREF(__pyx_t_1);
-  PyTuple_SET_ITEM(__pyx_t_16, 0, __pyx_t_1);
-  __Pyx_GIVEREF(__pyx_t_13);
-  PyTuple_SET_ITEM(__pyx_t_16, 1, __pyx_t_13);
+  __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
-  __pyx_t_13 = 0;
-  __pyx_t_13 = __Pyx_PyObject_Call(__pyx_builtin_property, __pyx_t_16, NULL); if (unlikely(!__pyx_t_13)) __PYX_ERR(1, 227, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_13);
-  __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
-  if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_input_arrays, __pyx_t_13) < 0) __PYX_ERR(1, 227, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+  goto __pyx_L0;
 
-  __pyx_t_13 = __Pyx_CyFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_8Function_19get_parameters, 0, __pyx_n_s_Function_get_parameters, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__389)); if (unlikely(!__pyx_t_13)) __PYX_ERR(1, 229, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_13);
-  if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_get_parameters, __pyx_t_13) < 0) __PYX_ERR(1, 229, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
 
-  __pyx_t_13 = __Pyx_CyFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_8Function_21set_parameters, 0, __pyx_n_s_Function_set_parameters, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__391)); if (unlikely(!__pyx_t_13)) __PYX_ERR(1, 238, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_13);
-  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_13, __pyx_tuple__392);
-  if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_set_parameters, __pyx_t_13) < 0) __PYX_ERR(1, 238, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("talib._ta_lib.stream_WILLR", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_high);
+  __Pyx_XDECREF((PyObject *)__pyx_v_low);
+  __Pyx_XDECREF((PyObject *)__pyx_v_close);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
 
-  __pyx_t_13 = PyObject_GetItem(__pyx_t_3, __pyx_n_s_get_parameters);
-  if (unlikely(!__pyx_t_13)) {
-    PyErr_Clear();
-    __Pyx_GetModuleGlobalName(__pyx_t_13, __pyx_n_s_get_parameters);
+
+/* Python wrapper */
+static PyObject *__pyx_pw_5talib_7_ta_lib_685stream_WMA(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_684stream_WMA, "stream_WMA(ndarray real, int timeperiod=-0x80000000)\n\nWMA(real[, timeperiod=?])\n\nWeighted Moving Average (Overlap Studies)\n\nInputs:\n    real: (any ndarray)\nParameters:\n    timeperiod: 30\nOutputs:\n    real");
+static PyMethodDef __pyx_mdef_5talib_7_ta_lib_685stream_WMA = {"stream_WMA", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_5talib_7_ta_lib_685stream_WMA, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_5talib_7_ta_lib_684stream_WMA};
+static PyObject *__pyx_pw_5talib_7_ta_lib_685stream_WMA(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyArrayObject *__pyx_v_real = 0;
+  int __pyx_v_timeperiod;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("stream_WMA (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_real,&__pyx_mstate_global->__pyx_n_u_timeperiod,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(5, 5322, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 5322, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 5322, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "stream_WMA", 0) < (0)) __PYX_ERR(5, 5322, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("stream_WMA", 0, 1, 2, i); __PYX_ERR(5, 5322, __pyx_L3_error) }
+      }
+    } else {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(5, 5322, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 5322, __pyx_L3_error)
+        break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+    }
+    __pyx_v_real = ((PyArrayObject *)values[0]);
+    if (values[1]) {
+      __pyx_v_timeperiod = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_timeperiod == (int)-1) && PyErr_Occurred())) __PYX_ERR(5, 5324, __pyx_L3_error)
+    } else {
+      __pyx_v_timeperiod = ((int)((int)-2147483648));
+    }
   }
-  if (unlikely(!__pyx_t_13)) __PYX_ERR(1, 250, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_13);
-  __pyx_t_16 = PyObject_GetItem(__pyx_t_3, __pyx_n_s_set_parameters);
-  if (unlikely(!__pyx_t_16)) {
-    PyErr_Clear();
-    __Pyx_GetModuleGlobalName(__pyx_t_16, __pyx_n_s_set_parameters);
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("stream_WMA", 0, 1, 2, __pyx_nargs); __PYX_ERR(5, 5322, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
   }
-  if (unlikely(!__pyx_t_16)) __PYX_ERR(1, 250, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_16);
-  __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 250, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_GIVEREF(__pyx_t_13);
-  PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_13);
-  __Pyx_GIVEREF(__pyx_t_16);
-  PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_16);
-  __pyx_t_13 = 0;
-  __pyx_t_16 = 0;
-  __pyx_t_16 = __Pyx_PyObject_Call(__pyx_builtin_property, __pyx_t_1, NULL); if (unlikely(!__pyx_t_16)) __PYX_ERR(1, 250, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_16);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_parameters, __pyx_t_16) < 0) __PYX_ERR(1, 250, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
+  __Pyx_AddTraceback("talib._ta_lib.stream_WMA", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_real), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 0, "real", 0))) __PYX_ERR(5, 5324, __pyx_L1_error)
+  __pyx_r = __pyx_pf_5talib_7_ta_lib_684stream_WMA(__pyx_self, __pyx_v_real, __pyx_v_timeperiod);
 
-  __pyx_t_16 = __Pyx_CyFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_8Function_23set_function_args, 0, __pyx_n_s_Function_set_function_args, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__394)); if (unlikely(!__pyx_t_16)) __PYX_ERR(1, 252, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_16);
-  if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_set_function_args, __pyx_t_16) < 0) __PYX_ERR(1, 252, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
+  __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
 
-  __pyx_t_16 = __Pyx_CyFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_8Function_25lookback, 0, __pyx_n_s_Function_lookback, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__396)); if (unlikely(!__pyx_t_16)) __PYX_ERR(1, 287, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_16);
+static PyObject *__pyx_pf_5talib_7_ta_lib_684stream_WMA(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real, int __pyx_v_timeperiod) {
+  npy_intp __pyx_v_length;
+  TA_RetCode __pyx_v_retCode;
+  double *__pyx_v_real_data;
+  int __pyx_v_outbegidx;
+  int __pyx_v_outnbelement;
+  double __pyx_v_outreal;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("stream_WMA", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_real);
 
-  __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_builtin_property, __pyx_t_16); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 286, __pyx_L1_error)
+  __pyx_t_1 = ((PyObject *)__pyx_f_5talib_7_ta_lib_check_array(__pyx_v_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 5343, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
-  if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_lookback, __pyx_t_1) < 0) __PYX_ERR(1, 287, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_1));
+  __pyx_t_1 = 0;
 
-  __pyx_t_1 = __Pyx_CyFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_8Function_27output_names, 0, __pyx_n_s_Function_output_names, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__398)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 307, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_real_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real));
 
-  __pyx_t_16 = __Pyx_PyObject_CallOneArg(__pyx_builtin_property, __pyx_t_1); if (unlikely(!__pyx_t_16)) __PYX_ERR(1, 306, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_16);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_output_names, __pyx_t_16) < 0) __PYX_ERR(1, 307, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
+  __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_real)[0]);
 
-  __pyx_t_16 = __Pyx_CyFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_8Function_29outputs, 0, __pyx_n_s_Function_outputs, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__400)); if (unlikely(!__pyx_t_16)) __PYX_ERR(1, 317, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_16);
+  __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN;
 
-  __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_builtin_property, __pyx_t_16); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 316, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
-  if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_outputs, __pyx_t_1) < 0) __PYX_ERR(1, 317, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v_retCode = TA_WMA((((int)__pyx_v_length) - 1), (((int)__pyx_v_length) - 1), __pyx_v_real_data, __pyx_v_timeperiod, (&__pyx_v_outbegidx), (&__pyx_v_outnbelement), (&__pyx_v_outreal));
 
-  __pyx_t_1 = __Pyx_CyFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_8Function_31run, 0, __pyx_n_s_Function_run, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__402)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 340, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_WMA, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 5348, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_1, __pyx_tuple__403);
-  if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_run, __pyx_t_1) < 0) __PYX_ERR(1, 340, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
-  __pyx_t_1 = __Pyx_CyFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_8Function_33__call__, 0, __pyx_n_s_Function___call, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__405)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 352, __pyx_L1_error)
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 5349, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_call, __pyx_t_1) < 0) __PYX_ERR(1, 352, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
 
-  __pyx_t_1 = __Pyx_CyFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_8Function_35__input_price_series_names, 0, __pyx_n_s_Function___input_price_series_na, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__407)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 400, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_Function__input_price_series_na, __pyx_t_1) < 0) __PYX_ERR(1, 400, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
-  __pyx_t_1 = __Pyx_CyFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_8Function_37__call_function, 0, __pyx_n_s_Function___call_function, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__409)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 411, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_Function__call_function, __pyx_t_1) < 0) __PYX_ERR(1, 411, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("talib._ta_lib.stream_WMA", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_real);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+/* #### Code section: module_exttypes ### */
 
-  __pyx_t_1 = __Pyx_CyFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_8Function_39__check_opt_input_value, 0, __pyx_n_s_Function___check_opt_input_value, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__411)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 438, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_Function__check_opt_input_value, __pyx_t_1) < 0) __PYX_ERR(1, 438, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+static PyMethodDef __pyx_methods[] = {
+  {0, 0, 0, 0}
+};
+/* #### Code section: initfunc_declarations ### */
+static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(__pyx_mstatetype *__pyx_mstate); /*proto*/
+static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(__pyx_mstatetype *__pyx_mstate); /*proto*/
+static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void); /*proto*/
+static CYTHON_SMALL_CODE int __Pyx_InitConstants(__pyx_mstatetype *__pyx_mstate); /*proto*/
+static CYTHON_SMALL_CODE int __Pyx_modinit_global_init_code(__pyx_mstatetype *__pyx_mstate); /*proto*/
+static CYTHON_SMALL_CODE int __Pyx_modinit_variable_export_code(__pyx_mstatetype *__pyx_mstate); /*proto*/
+static CYTHON_SMALL_CODE int __Pyx_modinit_function_export_code(__pyx_mstatetype *__pyx_mstate); /*proto*/
+static CYTHON_SMALL_CODE int __Pyx_modinit_type_init_code(__pyx_mstatetype *__pyx_mstate); /*proto*/
+static CYTHON_SMALL_CODE int __Pyx_modinit_type_import_code(__pyx_mstatetype *__pyx_mstate); /*proto*/
+static CYTHON_SMALL_CODE int __Pyx_modinit_variable_import_code(__pyx_mstatetype *__pyx_mstate); /*proto*/
+static CYTHON_SMALL_CODE int __Pyx_modinit_function_import_code(__pyx_mstatetype *__pyx_mstate); /*proto*/
+static CYTHON_SMALL_CODE int __Pyx_CreateCodeObjects(__pyx_mstatetype *__pyx_mstate); /*proto*/
+/* #### Code section: init_module ### */
+
+static int __Pyx_modinit_global_init_code(__pyx_mstatetype *__pyx_mstate) {
+  __Pyx_RefNannyDeclarations
+  CYTHON_UNUSED_VAR(__pyx_mstate);
+  __Pyx_RefNannySetupContext("__Pyx_modinit_global_init_code", 0);
+  /*--- Global init code ---*/
+  __Pyx_RefNannyFinishContext();
+  return 0;
+}
 
-  __pyx_t_1 = __Pyx_CyFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_8Function_41__get_opt_input_value, 0, __pyx_n_s_Function___get_opt_input_value, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__413)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 453, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_Function__get_opt_input_value, __pyx_t_1) < 0) __PYX_ERR(1, 453, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+static int __Pyx_modinit_variable_export_code(__pyx_mstatetype *__pyx_mstate) {
+  __Pyx_RefNannyDeclarations
+  CYTHON_UNUSED_VAR(__pyx_mstate);
+  __Pyx_RefNannySetupContext("__Pyx_modinit_variable_export_code", 0);
+  /*--- Variable export code ---*/
+  __Pyx_RefNannyFinishContext();
+  return 0;
+}
 
-  __pyx_t_1 = __Pyx_CyFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_8Function_43__repr__, 0, __pyx_n_s_Function___repr, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__415)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 462, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_repr, __pyx_t_1) < 0) __PYX_ERR(1, 462, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+static int __Pyx_modinit_function_export_code(__pyx_mstatetype *__pyx_mstate) {
+  __Pyx_RefNannyDeclarations
+  CYTHON_UNUSED_VAR(__pyx_mstate);
+  __Pyx_RefNannySetupContext("__Pyx_modinit_function_export_code", 0);
+  /*--- Function export code ---*/
+  __Pyx_RefNannyFinishContext();
+  return 0;
+}
 
-  __pyx_t_1 = __Pyx_CyFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_8Function_45__unicode__, 0, __pyx_n_s_Function___unicode, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__417)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 465, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_unicode, __pyx_t_1) < 0) __PYX_ERR(1, 465, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+static int __Pyx_modinit_type_init_code(__pyx_mstatetype *__pyx_mstate) {
+  __Pyx_RefNannyDeclarations
+  CYTHON_UNUSED_VAR(__pyx_mstate);
+  __Pyx_RefNannySetupContext("__Pyx_modinit_type_init_code", 0);
+  /*--- Type init code ---*/
+  __Pyx_RefNannyFinishContext();
+  return 0;
+}
 
-  __pyx_t_1 = __Pyx_CyFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_8Function_47__str__, 0, __pyx_n_s_Function___str, NULL, __pyx_n_s_talib__ta_lib, __pyx_d, ((PyObject *)__pyx_codeobj__419)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 468, __pyx_L1_error)
+static int __Pyx_modinit_type_import_code(__pyx_mstatetype *__pyx_mstate) {
+  __Pyx_RefNannyDeclarations
+  CYTHON_UNUSED_VAR(__pyx_mstate);
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__Pyx_modinit_type_import_code", 0);
+  /*--- Type import code ---*/
+  __pyx_t_1 = PyImport_ImportModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 9, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_str, __pyx_t_1) < 0) __PYX_ERR(1, 468, __pyx_L1_error)
+  __pyx_mstate->__pyx_ptype_7cpython_4type_type = __Pyx_ImportType_3_1_5(__pyx_t_1, __Pyx_BUILTIN_MODULE_NAME, "type",
+  #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000
+  sizeof(PyTypeObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_5(PyTypeObject),
+  #elif CYTHON_COMPILING_IN_LIMITED_API
+  0, 0,
+  #else
+  sizeof(PyHeapTypeObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_5(PyHeapTypeObject),
+  #endif
+  __Pyx_ImportType_CheckSize_Warn_3_1_5); if (!__pyx_mstate->__pyx_ptype_7cpython_4type_type) __PYX_ERR(6, 9, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-
-  __pyx_t_1 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_Function, __pyx_tuple__369, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 61, __pyx_L1_error)
+  __pyx_t_1 = PyImport_ImportModule("numpy"); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 271, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_Function, __pyx_t_1) < 0) __PYX_ERR(1, 61, __pyx_L1_error)
+  __pyx_mstate->__pyx_ptype_5numpy_dtype = __Pyx_ImportType_3_1_5(__pyx_t_1, "numpy", "dtype",
+  #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000
+  sizeof(PyArray_Descr), __PYX_GET_STRUCT_ALIGNMENT_3_1_5(PyArray_Descr),
+  #elif CYTHON_COMPILING_IN_LIMITED_API
+  sizeof(PyArray_Descr), __PYX_GET_STRUCT_ALIGNMENT_3_1_5(PyArray_Descr),
+  #else
+  sizeof(PyArray_Descr), __PYX_GET_STRUCT_ALIGNMENT_3_1_5(PyArray_Descr),
+  #endif
+  __Pyx_ImportType_CheckSize_Ignore_3_1_5); if (!__pyx_mstate->__pyx_ptype_5numpy_dtype) __PYX_ERR(3, 271, __pyx_L1_error)
+  __pyx_mstate->__pyx_ptype_5numpy_flatiter = __Pyx_ImportType_3_1_5(__pyx_t_1, "numpy", "flatiter",
+  #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000
+  sizeof(PyArrayIterObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_5(PyArrayIterObject),
+  #elif CYTHON_COMPILING_IN_LIMITED_API
+  sizeof(PyArrayIterObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_5(PyArrayIterObject),
+  #else
+  sizeof(PyArrayIterObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_5(PyArrayIterObject),
+  #endif
+  __Pyx_ImportType_CheckSize_Ignore_3_1_5); if (!__pyx_mstate->__pyx_ptype_5numpy_flatiter) __PYX_ERR(3, 316, __pyx_L1_error)
+  __pyx_mstate->__pyx_ptype_5numpy_broadcast = __Pyx_ImportType_3_1_5(__pyx_t_1, "numpy", "broadcast",
+  #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000
+  sizeof(PyArrayMultiIterObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_5(PyArrayMultiIterObject),
+  #elif CYTHON_COMPILING_IN_LIMITED_API
+  sizeof(PyArrayMultiIterObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_5(PyArrayMultiIterObject),
+  #else
+  sizeof(PyArrayMultiIterObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_5(PyArrayMultiIterObject),
+  #endif
+  __Pyx_ImportType_CheckSize_Ignore_3_1_5); if (!__pyx_mstate->__pyx_ptype_5numpy_broadcast) __PYX_ERR(3, 320, __pyx_L1_error)
+  __pyx_mstate->__pyx_ptype_5numpy_ndarray = __Pyx_ImportType_3_1_5(__pyx_t_1, "numpy", "ndarray",
+  #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000
+  sizeof(PyArrayObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_5(PyArrayObject),
+  #elif CYTHON_COMPILING_IN_LIMITED_API
+  sizeof(PyArrayObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_5(PyArrayObject),
+  #else
+  sizeof(PyArrayObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_5(PyArrayObject),
+  #endif
+  __Pyx_ImportType_CheckSize_Ignore_3_1_5); if (!__pyx_mstate->__pyx_ptype_5numpy_ndarray) __PYX_ERR(3, 359, __pyx_L1_error)
+  __pyx_mstate->__pyx_ptype_5numpy_generic = __Pyx_ImportType_3_1_5(__pyx_t_1, "numpy", "generic",
+  #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000
+  sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_5(PyObject),
+  #elif CYTHON_COMPILING_IN_LIMITED_API
+  sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_5(PyObject),
+  #else
+  sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_5(PyObject),
+  #endif
+  __Pyx_ImportType_CheckSize_Warn_3_1_5); if (!__pyx_mstate->__pyx_ptype_5numpy_generic) __PYX_ERR(3, 864, __pyx_L1_error)
+  __pyx_mstate->__pyx_ptype_5numpy_number = __Pyx_ImportType_3_1_5(__pyx_t_1, "numpy", "number",
+  #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000
+  sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_5(PyObject),
+  #elif CYTHON_COMPILING_IN_LIMITED_API
+  sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_5(PyObject),
+  #else
+  sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_5(PyObject),
+  #endif
+  __Pyx_ImportType_CheckSize_Warn_3_1_5); if (!__pyx_mstate->__pyx_ptype_5numpy_number) __PYX_ERR(3, 866, __pyx_L1_error)
+  __pyx_mstate->__pyx_ptype_5numpy_integer = __Pyx_ImportType_3_1_5(__pyx_t_1, "numpy", "integer",
+  #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000
+  sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_5(PyObject),
+  #elif CYTHON_COMPILING_IN_LIMITED_API
+  sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_5(PyObject),
+  #else
+  sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_5(PyObject),
+  #endif
+  __Pyx_ImportType_CheckSize_Warn_3_1_5); if (!__pyx_mstate->__pyx_ptype_5numpy_integer) __PYX_ERR(3, 868, __pyx_L1_error)
+  __pyx_mstate->__pyx_ptype_5numpy_signedinteger = __Pyx_ImportType_3_1_5(__pyx_t_1, "numpy", "signedinteger",
+  #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000
+  sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_5(PyObject),
+  #elif CYTHON_COMPILING_IN_LIMITED_API
+  sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_5(PyObject),
+  #else
+  sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_5(PyObject),
+  #endif
+  __Pyx_ImportType_CheckSize_Warn_3_1_5); if (!__pyx_mstate->__pyx_ptype_5numpy_signedinteger) __PYX_ERR(3, 870, __pyx_L1_error)
+  __pyx_mstate->__pyx_ptype_5numpy_unsignedinteger = __Pyx_ImportType_3_1_5(__pyx_t_1, "numpy", "unsignedinteger",
+  #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000
+  sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_5(PyObject),
+  #elif CYTHON_COMPILING_IN_LIMITED_API
+  sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_5(PyObject),
+  #else
+  sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_5(PyObject),
+  #endif
+  __Pyx_ImportType_CheckSize_Warn_3_1_5); if (!__pyx_mstate->__pyx_ptype_5numpy_unsignedinteger) __PYX_ERR(3, 872, __pyx_L1_error)
+  __pyx_mstate->__pyx_ptype_5numpy_inexact = __Pyx_ImportType_3_1_5(__pyx_t_1, "numpy", "inexact",
+  #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000
+  sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_5(PyObject),
+  #elif CYTHON_COMPILING_IN_LIMITED_API
+  sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_5(PyObject),
+  #else
+  sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_5(PyObject),
+  #endif
+  __Pyx_ImportType_CheckSize_Warn_3_1_5); if (!__pyx_mstate->__pyx_ptype_5numpy_inexact) __PYX_ERR(3, 874, __pyx_L1_error)
+  __pyx_mstate->__pyx_ptype_5numpy_floating = __Pyx_ImportType_3_1_5(__pyx_t_1, "numpy", "floating",
+  #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000
+  sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_5(PyObject),
+  #elif CYTHON_COMPILING_IN_LIMITED_API
+  sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_5(PyObject),
+  #else
+  sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_5(PyObject),
+  #endif
+  __Pyx_ImportType_CheckSize_Warn_3_1_5); if (!__pyx_mstate->__pyx_ptype_5numpy_floating) __PYX_ERR(3, 876, __pyx_L1_error)
+  __pyx_mstate->__pyx_ptype_5numpy_complexfloating = __Pyx_ImportType_3_1_5(__pyx_t_1, "numpy", "complexfloating",
+  #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000
+  sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_5(PyObject),
+  #elif CYTHON_COMPILING_IN_LIMITED_API
+  sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_5(PyObject),
+  #else
+  sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_5(PyObject),
+  #endif
+  __Pyx_ImportType_CheckSize_Warn_3_1_5); if (!__pyx_mstate->__pyx_ptype_5numpy_complexfloating) __PYX_ERR(3, 878, __pyx_L1_error)
+  __pyx_mstate->__pyx_ptype_5numpy_flexible = __Pyx_ImportType_3_1_5(__pyx_t_1, "numpy", "flexible",
+  #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000
+  sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_5(PyObject),
+  #elif CYTHON_COMPILING_IN_LIMITED_API
+  sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_5(PyObject),
+  #else
+  sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_5(PyObject),
+  #endif
+  __Pyx_ImportType_CheckSize_Warn_3_1_5); if (!__pyx_mstate->__pyx_ptype_5numpy_flexible) __PYX_ERR(3, 880, __pyx_L1_error)
+  __pyx_mstate->__pyx_ptype_5numpy_character = __Pyx_ImportType_3_1_5(__pyx_t_1, "numpy", "character",
+  #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000
+  sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_5(PyObject),
+  #elif CYTHON_COMPILING_IN_LIMITED_API
+  sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_5(PyObject),
+  #else
+  sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_5(PyObject),
+  #endif
+  __Pyx_ImportType_CheckSize_Warn_3_1_5); if (!__pyx_mstate->__pyx_ptype_5numpy_character) __PYX_ERR(3, 882, __pyx_L1_error)
+  __pyx_mstate->__pyx_ptype_5numpy_ufunc = __Pyx_ImportType_3_1_5(__pyx_t_1, "numpy", "ufunc",
+  #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000
+  sizeof(PyUFuncObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_5(PyUFuncObject),
+  #elif CYTHON_COMPILING_IN_LIMITED_API
+  sizeof(PyUFuncObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_5(PyUFuncObject),
+  #else
+  sizeof(PyUFuncObject), __PYX_GET_STRUCT_ALIGNMENT_3_1_5(PyUFuncObject),
+  #endif
+  __Pyx_ImportType_CheckSize_Ignore_3_1_5); if (!__pyx_mstate->__pyx_ptype_5numpy_ufunc) __PYX_ERR(3, 946, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_343_ta_getGroupTable, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 482, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_ta_getGroupTable, __pyx_t_2) < 0) __PYX_ERR(1, 482, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_345_ta_getFuncTable, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 494, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_ta_getFuncTable, __pyx_t_2) < 0) __PYX_ERR(1, 494, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_347__get_flags, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 506, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_get_flags, __pyx_t_2) < 0) __PYX_ERR(1, 506, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-
-  __pyx_t_2 = __Pyx_PyDict_NewPresized(4); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 532, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_t_2, __pyx_int_16777216, __pyx_kp_s_Output_scale_same_as_input) < 0) __PYX_ERR(1, 532, __pyx_L1_error)
-  if (PyDict_SetItem(__pyx_t_2, __pyx_int_67108864, __pyx_kp_s_Output_is_over_volume) < 0) __PYX_ERR(1, 532, __pyx_L1_error)
-  if (PyDict_SetItem(__pyx_t_2, __pyx_int_134217728, __pyx_kp_s_Function_has_an_unstable_period) < 0) __PYX_ERR(1, 532, __pyx_L1_error)
-  if (PyDict_SetItem(__pyx_t_2, __pyx_int_268435456, __pyx_kp_s_Output_is_a_candlestick) < 0) __PYX_ERR(1, 532, __pyx_L1_error)
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_TA_FUNC_FLAGS, __pyx_t_2) < 0) __PYX_ERR(1, 531, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-
-  __pyx_t_2 = __Pyx_PyDict_NewPresized(7); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 540, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_t_2, __pyx_int_1, __pyx_n_s_open) < 0) __PYX_ERR(1, 540, __pyx_L1_error)
-  if (PyDict_SetItem(__pyx_t_2, __pyx_int_2, __pyx_n_s_high) < 0) __PYX_ERR(1, 540, __pyx_L1_error)
-  if (PyDict_SetItem(__pyx_t_2, __pyx_int_4, __pyx_n_s_low) < 0) __PYX_ERR(1, 540, __pyx_L1_error)
-  if (PyDict_SetItem(__pyx_t_2, __pyx_int_8, __pyx_n_s_close) < 0) __PYX_ERR(1, 540, __pyx_L1_error)
-  if (PyDict_SetItem(__pyx_t_2, __pyx_int_16, __pyx_n_s_volume) < 0) __PYX_ERR(1, 540, __pyx_L1_error)
-  if (PyDict_SetItem(__pyx_t_2, __pyx_int_32, __pyx_n_s_openInterest) < 0) __PYX_ERR(1, 540, __pyx_L1_error)
-  if (PyDict_SetItem(__pyx_t_2, __pyx_int_64, __pyx_n_s_timeStamp) < 0) __PYX_ERR(1, 540, __pyx_L1_error)
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_TA_INPUT_FLAGS, __pyx_t_2) < 0) __PYX_ERR(1, 539, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-
-  __pyx_t_2 = __Pyx_PyDict_NewPresized(13); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 550, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_t_2, __pyx_int_1, __pyx_n_s_Line) < 0) __PYX_ERR(1, 550, __pyx_L1_error)
-  if (PyDict_SetItem(__pyx_t_2, __pyx_int_2, __pyx_kp_s_Dotted_Line) < 0) __PYX_ERR(1, 550, __pyx_L1_error)
-  if (PyDict_SetItem(__pyx_t_2, __pyx_int_4, __pyx_kp_s_Dashed_Line) < 0) __PYX_ERR(1, 550, __pyx_L1_error)
-  if (PyDict_SetItem(__pyx_t_2, __pyx_int_8, __pyx_n_s_Dot) < 0) __PYX_ERR(1, 550, __pyx_L1_error)
-  if (PyDict_SetItem(__pyx_t_2, __pyx_int_16, __pyx_n_s_Histogram) < 0) __PYX_ERR(1, 550, __pyx_L1_error)
-  if (PyDict_SetItem(__pyx_t_2, __pyx_int_32, __pyx_kp_s_Pattern_Bool) < 0) __PYX_ERR(1, 550, __pyx_L1_error)
-  if (PyDict_SetItem(__pyx_t_2, __pyx_int_64, __pyx_kp_s_Bull_Bear_Pattern_Bearish_0_Neut) < 0) __PYX_ERR(1, 550, __pyx_L1_error)
-  if (PyDict_SetItem(__pyx_t_2, __pyx_int_128, __pyx_kp_s_Strength_Pattern_200_100_Bearish) < 0) __PYX_ERR(1, 550, __pyx_L1_error)
-  if (PyDict_SetItem(__pyx_t_2, __pyx_int_256, __pyx_kp_s_Output_can_be_positive) < 0) __PYX_ERR(1, 550, __pyx_L1_error)
-  if (PyDict_SetItem(__pyx_t_2, __pyx_int_512, __pyx_kp_s_Output_can_be_negative) < 0) __PYX_ERR(1, 550, __pyx_L1_error)
-  if (PyDict_SetItem(__pyx_t_2, __pyx_int_1024, __pyx_kp_s_Output_can_be_zero) < 0) __PYX_ERR(1, 550, __pyx_L1_error)
-  if (PyDict_SetItem(__pyx_t_2, __pyx_int_2048, __pyx_kp_s_Values_represent_an_upper_limit) < 0) __PYX_ERR(1, 550, __pyx_L1_error)
-  if (PyDict_SetItem(__pyx_t_2, __pyx_int_4096, __pyx_kp_s_Values_represent_a_lower_limit) < 0) __PYX_ERR(1, 550, __pyx_L1_error)
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_TA_OUTPUT_FLAGS, __pyx_t_2) < 0) __PYX_ERR(1, 549, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_349_ta_getFuncInfo, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 565, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_ta_getFuncInfo, __pyx_t_2) < 0) __PYX_ERR(1, 565, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_351_ta_getInputParameterInfo, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 584, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_ta_getInputParameterInfo, __pyx_t_2) < 0) __PYX_ERR(1, 584, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_353_ta_getOptInputParameterInfo, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 605, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_ta_getOptInputParameterInfo, __pyx_t_2) < 0) __PYX_ERR(1, 605, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_355_ta_getOutputParameterInfo, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 629, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_ta_getOutputParameterInfo, __pyx_t_2) < 0) __PYX_ERR(1, 629, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_357_get_defaults_and_docs, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 649, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_get_defaults_and_docs, __pyx_t_2) < 0) __PYX_ERR(1, 649, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_359stream_ACOS, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 11, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_ACOS, __pyx_t_2) < 0) __PYX_ERR(3, 11, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_361stream_AD, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 38, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_AD, __pyx_t_2) < 0) __PYX_ERR(3, 38, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_363stream_ADD, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 74, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_ADD, __pyx_t_2) < 0) __PYX_ERR(3, 74, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_365stream_ADOSC, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 105, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_ADOSC, __pyx_t_2) < 0) __PYX_ERR(3, 105, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_367stream_ADX, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 144, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_ADX, __pyx_t_2) < 0) __PYX_ERR(3, 144, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_369stream_ADXR, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 179, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_ADXR, __pyx_t_2) < 0) __PYX_ERR(3, 179, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_371stream_APO, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 214, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_APO, __pyx_t_2) < 0) __PYX_ERR(3, 214, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_373stream_AROON, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 245, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_AROON, __pyx_t_2) < 0) __PYX_ERR(3, 245, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_RefNannyFinishContext();
+  return 0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_RefNannyFinishContext();
+  return -1;
+}
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_375stream_AROONOSC, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 280, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_AROONOSC, __pyx_t_2) < 0) __PYX_ERR(3, 280, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+static int __Pyx_modinit_variable_import_code(__pyx_mstatetype *__pyx_mstate) {
+  __Pyx_RefNannyDeclarations
+  CYTHON_UNUSED_VAR(__pyx_mstate);
+  __Pyx_RefNannySetupContext("__Pyx_modinit_variable_import_code", 0);
+  /*--- Variable import code ---*/
+  __Pyx_RefNannyFinishContext();
+  return 0;
+}
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_377stream_ASIN, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 312, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_ASIN, __pyx_t_2) < 0) __PYX_ERR(3, 312, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+static int __Pyx_modinit_function_import_code(__pyx_mstatetype *__pyx_mstate) {
+  __Pyx_RefNannyDeclarations
+  CYTHON_UNUSED_VAR(__pyx_mstate);
+  __Pyx_RefNannySetupContext("__Pyx_modinit_function_import_code", 0);
+  /*--- Function import code ---*/
+  __Pyx_RefNannyFinishContext();
+  return 0;
+}
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_379stream_ATAN, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 339, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_ATAN, __pyx_t_2) < 0) __PYX_ERR(3, 339, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+#if CYTHON_PEP489_MULTI_PHASE_INIT
+static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/
+static int __pyx_pymod_exec__ta_lib(PyObject* module); /*proto*/
+static PyModuleDef_Slot __pyx_moduledef_slots[] = {
+  {Py_mod_create, (void*)__pyx_pymod_create},
+  {Py_mod_exec, (void*)__pyx_pymod_exec__ta_lib},
+  #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING
+  {Py_mod_gil, Py_MOD_GIL_USED},
+  #endif
+  #if PY_VERSION_HEX >= 0x030C0000 && CYTHON_USE_MODULE_STATE
+  {Py_mod_multiple_interpreters, Py_MOD_MULTIPLE_INTERPRETERS_NOT_SUPPORTED},
+  #endif
+  {0, NULL}
+};
+#endif
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_381stream_ATR, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 366, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_ATR, __pyx_t_2) < 0) __PYX_ERR(3, 366, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+#ifdef __cplusplus
+namespace {
+  struct PyModuleDef __pyx_moduledef =
+  #else
+  static struct PyModuleDef __pyx_moduledef =
+  #endif
+  {
+      PyModuleDef_HEAD_INIT,
+      "_ta_lib",
+      0, /* m_doc */
+    #if CYTHON_USE_MODULE_STATE
+      sizeof(__pyx_mstatetype), /* m_size */
+    #else
+      (CYTHON_PEP489_MULTI_PHASE_INIT) ? 0 : -1, /* m_size */
+    #endif
+      __pyx_methods /* m_methods */,
+    #if CYTHON_PEP489_MULTI_PHASE_INIT
+      __pyx_moduledef_slots, /* m_slots */
+    #else
+      NULL, /* m_reload */
+    #endif
+    #if CYTHON_USE_MODULE_STATE
+      __pyx_m_traverse, /* m_traverse */
+      __pyx_m_clear, /* m_clear */
+      NULL /* m_free */
+    #else
+      NULL, /* m_traverse */
+      NULL, /* m_clear */
+      NULL /* m_free */
+    #endif
+  };
+  #ifdef __cplusplus
+} /* anonymous namespace */
+#endif
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_383stream_AVGPRICE, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 401, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_AVGPRICE, __pyx_t_2) < 0) __PYX_ERR(3, 401, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+/* PyModInitFuncType */
+#ifndef CYTHON_NO_PYINIT_EXPORT
+  #define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC
+#else
+  #ifdef __cplusplus
+  #define __Pyx_PyMODINIT_FUNC extern "C" PyObject *
+  #else
+  #define __Pyx_PyMODINIT_FUNC PyObject *
+  #endif
+#endif
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_385stream_BBANDS, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 437, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_BBANDS, __pyx_t_2) < 0) __PYX_ERR(3, 437, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+__Pyx_PyMODINIT_FUNC PyInit__ta_lib(void) CYTHON_SMALL_CODE; /*proto*/
+__Pyx_PyMODINIT_FUNC PyInit__ta_lib(void)
+#if CYTHON_PEP489_MULTI_PHASE_INIT
+{
+  return PyModuleDef_Init(&__pyx_moduledef);
+}
+/* ModuleCreationPEP489 */
+#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x03090000
+static PY_INT64_T __Pyx_GetCurrentInterpreterId(void) {
+    {
+        PyObject *module = PyImport_ImportModule("_interpreters"); // 3.13+ I think
+        if (!module) {
+            PyErr_Clear(); // just try the 3.8-3.12 version
+            module = PyImport_ImportModule("_xxsubinterpreters");
+            if (!module) goto bad;
+        }
+        PyObject *current = PyObject_CallMethod(module, "get_current", NULL);
+        Py_DECREF(module);
+        if (!current) goto bad;
+        if (PyTuple_Check(current)) {
+            PyObject *new_current = PySequence_GetItem(current, 0);
+            Py_DECREF(current);
+            current = new_current;
+            if (!new_current) goto bad;
+        }
+        long long as_c_int = PyLong_AsLongLong(current);
+        Py_DECREF(current);
+        return as_c_int;
+    }
+  bad:
+    PySys_WriteStderr("__Pyx_GetCurrentInterpreterId failed. Try setting the C define CYTHON_PEP489_MULTI_PHASE_INIT=0\n");
+    return -1;
+}
+#endif
+#if !CYTHON_USE_MODULE_STATE
+static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) {
+    static PY_INT64_T main_interpreter_id = -1;
+#if CYTHON_COMPILING_IN_GRAAL
+    PY_INT64_T current_id = PyInterpreterState_GetIDFromThreadState(PyThreadState_Get());
+#elif CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX >= 0x03090000
+    PY_INT64_T current_id = PyInterpreterState_GetID(PyInterpreterState_Get());
+#elif CYTHON_COMPILING_IN_LIMITED_API
+    PY_INT64_T current_id = __Pyx_GetCurrentInterpreterId();
+#else
+    PY_INT64_T current_id = PyInterpreterState_GetID(PyThreadState_Get()->interp);
+#endif
+    if (unlikely(current_id == -1)) {
+        return -1;
+    }
+    if (main_interpreter_id == -1) {
+        main_interpreter_id = current_id;
+        return 0;
+    } else if (unlikely(main_interpreter_id != current_id)) {
+        PyErr_SetString(
+            PyExc_ImportError,
+            "Interpreter change detected - this module can only be loaded into one interpreter per process.");
+        return -1;
+    }
+    return 0;
+}
+#endif
+static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none)
+{
+    PyObject *value = PyObject_GetAttrString(spec, from_name);
+    int result = 0;
+    if (likely(value)) {
+        if (allow_none || value != Py_None) {
+            result = PyDict_SetItemString(moddict, to_name, value);
+        }
+        Py_DECREF(value);
+    } else if (PyErr_ExceptionMatches(PyExc_AttributeError)) {
+        PyErr_Clear();
+    } else {
+        result = -1;
+    }
+    return result;
+}
+static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def) {
+    PyObject *module = NULL, *moddict, *modname;
+    CYTHON_UNUSED_VAR(def);
+    #if !CYTHON_USE_MODULE_STATE
+    if (__Pyx_check_single_interpreter())
+        return NULL;
+    #endif
+    if (__pyx_m)
+        return __Pyx_NewRef(__pyx_m);
+    modname = PyObject_GetAttrString(spec, "name");
+    if (unlikely(!modname)) goto bad;
+    module = PyModule_NewObject(modname);
+    Py_DECREF(modname);
+    if (unlikely(!module)) goto bad;
+    moddict = PyModule_GetDict(module);
+    if (unlikely(!moddict)) goto bad;
+    if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "loader", "__loader__", 1) < 0)) goto bad;
+    if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "origin", "__file__", 1) < 0)) goto bad;
+    if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "parent", "__package__", 1) < 0)) goto bad;
+    if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "submodule_search_locations", "__path__", 0) < 0)) goto bad;
+    return module;
+bad:
+    Py_XDECREF(module);
+    return NULL;
+}
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_387stream_BETA, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 475, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_BETA, __pyx_t_2) < 0) __PYX_ERR(3, 475, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_389stream_BOP, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 508, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_BOP, __pyx_t_2) < 0) __PYX_ERR(3, 508, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+static CYTHON_SMALL_CODE int __pyx_pymod_exec__ta_lib(PyObject *__pyx_pyinit_module)
+#endif
+{
+  int stringtab_initialized = 0;
+  #if CYTHON_USE_MODULE_STATE
+  int pystate_addmodule_run = 0;
+  #endif
+  __pyx_mstatetype *__pyx_mstate = NULL;
+  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;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  size_t __pyx_t_8;
+  PyObject *__pyx_t_9 = NULL;
+  PyObject *__pyx_t_10 = NULL;
+  PyObject *__pyx_t_11 = NULL;
+  PyObject *__pyx_t_12 = NULL;
+  PyObject *__pyx_t_13 = NULL;
+  PyObject *__pyx_t_14 = NULL;
+  PyObject *__pyx_t_15 = NULL;
+  PyObject *__pyx_t_16 = NULL;
+  PyObject *(*__pyx_t_17)(PyObject *);
+  Py_ssize_t __pyx_t_18;
+  PyObject *__pyx_t_19 = NULL;
+  PyObject *__pyx_t_20 = NULL;
+  PyObject *__pyx_t_21 = NULL;
+  double __pyx_t_22;
+  int __pyx_t_23;
+  PyObject *__pyx_t_24 = NULL;
+  PyObject *__pyx_t_25 = NULL;
+  int __pyx_t_26;
+  PyObject *__pyx_t_27 = NULL;
+  PyObject *__pyx_t_28 = NULL;
+  PyObject *__pyx_t_29 = NULL;
+  int __pyx_t_30;
+  int __pyx_t_31;
+  int __pyx_t_32;
+  PyObject *(*__pyx_t_33)(PyObject *);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannyDeclarations
+  #if CYTHON_PEP489_MULTI_PHASE_INIT
+  if (__pyx_m) {
+    if (__pyx_m == __pyx_pyinit_module) return 0;
+    PyErr_SetString(PyExc_RuntimeError, "Module '_ta_lib' has already been imported. Re-initialisation is not supported.");
+    return -1;
+  }
+  #else
+  if (__pyx_m) return __Pyx_NewRef(__pyx_m);
+  #endif
+  /*--- Module creation code ---*/
+  #if CYTHON_PEP489_MULTI_PHASE_INIT
+  __pyx_t_1 = __pyx_pyinit_module;
+  Py_INCREF(__pyx_t_1);
+  #else
+  __pyx_t_1 = PyModule_Create(&__pyx_moduledef); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error)
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  {
+    int add_module_result = __Pyx_State_AddModule(__pyx_t_1, &__pyx_moduledef);
+    __pyx_t_1 = 0; /* transfer ownership from __pyx_t_1 to "_ta_lib" pseudovariable */
+    if (unlikely((add_module_result < 0))) __PYX_ERR(0, 1, __pyx_L1_error)
+    pystate_addmodule_run = 1;
+  }
+  #else
+  __pyx_m = __pyx_t_1;
+  #endif
+  #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING
+  PyUnstable_Module_SetGIL(__pyx_m, Py_MOD_GIL_USED);
+  #endif
+  __pyx_mstate = __pyx_mstate_global;
+  CYTHON_UNUSED_VAR(__pyx_t_1);
+  __pyx_mstate->__pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_mstate->__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error)
+  Py_INCREF(__pyx_mstate->__pyx_d);
+  __pyx_mstate->__pyx_b = __Pyx_PyImport_AddModuleRef(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_mstate->__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __pyx_mstate->__pyx_cython_runtime = __Pyx_PyImport_AddModuleRef("cython_runtime"); if (unlikely(!__pyx_mstate->__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error)
+  if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_mstate->__pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  /* ImportRefnannyAPI */
+  #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_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_391stream_CCI, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 544, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CCI, __pyx_t_2) < 0) __PYX_ERR(3, 544, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+__Pyx_RefNannySetupContext("PyInit__ta_lib", 0);
+  if (__Pyx_check_binary_version(__PYX_LIMITED_VERSION_HEX, __Pyx_get_runtime_version(), CYTHON_COMPILING_IN_LIMITED_API) < (0)) __PYX_ERR(0, 1, __pyx_L1_error)
+  #ifdef __Pxy_PyFrame_Initialize_Offsets
+  __Pxy_PyFrame_Initialize_Offsets();
+  #endif
+  __pyx_mstate->__pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_mstate->__pyx_empty_tuple)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __pyx_mstate->__pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_mstate->__pyx_empty_bytes)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __pyx_mstate->__pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_mstate->__pyx_empty_unicode)) __PYX_ERR(0, 1, __pyx_L1_error)
+  /*--- Initialize various global constants etc. ---*/
+  if (__Pyx_InitConstants(__pyx_mstate) < (0)) __PYX_ERR(0, 1, __pyx_L1_error)
+  stringtab_initialized = 1;
+  if (__Pyx_InitGlobals() < (0)) __PYX_ERR(0, 1, __pyx_L1_error)
+  #if 0 || defined(__Pyx_CyFunction_USED) || defined(__Pyx_FusedFunction_USED) || defined(__Pyx_Coroutine_USED) || defined(__Pyx_Generator_USED) || defined(__Pyx_AsyncGen_USED)
+  if (__pyx_CommonTypesMetaclass_init(__pyx_m) < (0)) __PYX_ERR(0, 1, __pyx_L1_error)
+  #endif
+  #ifdef __Pyx_CyFunction_USED
+  if (__pyx_CyFunction_init(__pyx_m) < (0)) __PYX_ERR(0, 1, __pyx_L1_error)
+  #endif
+  #ifdef __Pyx_FusedFunction_USED
+  if (__pyx_FusedFunction_init(__pyx_m) < (0)) __PYX_ERR(0, 1, __pyx_L1_error)
+  #endif
+  #ifdef __Pyx_Coroutine_USED
+  if (__pyx_Coroutine_init(__pyx_m) < (0)) __PYX_ERR(0, 1, __pyx_L1_error)
+  #endif
+  #ifdef __Pyx_Generator_USED
+  if (__pyx_Generator_init(__pyx_m) < (0)) __PYX_ERR(0, 1, __pyx_L1_error)
+  #endif
+  #ifdef __Pyx_AsyncGen_USED
+  if (__pyx_AsyncGen_init(__pyx_m) < (0)) __PYX_ERR(0, 1, __pyx_L1_error)
+  #endif
+  /*--- Library function declarations ---*/
+  if (__pyx_module_is_main_talib___ta_lib) {
+    if (PyObject_SetAttr(__pyx_m, __pyx_mstate_global->__pyx_n_u_name_2, __pyx_mstate_global->__pyx_n_u_main) < (0)) __PYX_ERR(0, 1, __pyx_L1_error)
+  }
+  {
+    PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(0, 1, __pyx_L1_error)
+    if (!PyDict_GetItemString(modules, "talib._ta_lib")) {
+      if (unlikely((PyDict_SetItemString(modules, "talib._ta_lib", __pyx_m) < 0))) __PYX_ERR(0, 1, __pyx_L1_error)
+    }
+  }
+  /*--- Builtin init code ---*/
+  if (__Pyx_InitCachedBuiltins(__pyx_mstate) < (0)) __PYX_ERR(0, 1, __pyx_L1_error)
+  /*--- Constants init code ---*/
+  if (__Pyx_InitCachedConstants(__pyx_mstate) < (0)) __PYX_ERR(0, 1, __pyx_L1_error)
+  if (__Pyx_CreateCodeObjects(__pyx_mstate) < (0)) __PYX_ERR(0, 1, __pyx_L1_error)
+  /*--- Global type/function init code ---*/
+  (void)__Pyx_modinit_global_init_code(__pyx_mstate);
+  (void)__Pyx_modinit_variable_export_code(__pyx_mstate);
+  (void)__Pyx_modinit_function_export_code(__pyx_mstate);
+  (void)__Pyx_modinit_type_init_code(__pyx_mstate);
+  if (unlikely((__Pyx_modinit_type_import_code(__pyx_mstate) < 0))) __PYX_ERR(0, 1, __pyx_L1_error)
+  (void)__Pyx_modinit_variable_import_code(__pyx_mstate);
+  (void)__Pyx_modinit_function_import_code(__pyx_mstate);
+  /*--- Execution code ---*/
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_393stream_CDL2CROWS, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 579, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyBytes_FromString(TA_GetVersionString()); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 4, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDL2CROWS, __pyx_t_2) < 0) __PYX_ERR(3, 579, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ta_version, __pyx_t_2) < (0)) __PYX_ERR(1, 4, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_395stream_CDL3BLACKCROWS, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 615, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_1_ta_check_success, 0, __pyx_mstate_global->__pyx_n_u_ta_check_success, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[0])); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 6, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDL3BLACKCROWS, __pyx_t_2) < 0) __PYX_ERR(3, 615, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ta_check_success, __pyx_t_2) < (0)) __PYX_ERR(1, 6, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_397stream_CDL3INSIDE, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 651, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_3_ta_initialize, 0, __pyx_mstate_global->__pyx_n_u_ta_initialize, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[1])); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 50, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDL3INSIDE, __pyx_t_2) < 0) __PYX_ERR(3, 651, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ta_initialize, __pyx_t_2) < (0)) __PYX_ERR(1, 50, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_399stream_CDL3LINESTRIKE, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 687, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_5_ta_shutdown, 0, __pyx_mstate_global->__pyx_n_u_ta_shutdown, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[2])); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 55, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDL3LINESTRIKE, __pyx_t_2) < 0) __PYX_ERR(3, 687, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ta_shutdown, __pyx_t_2) < (0)) __PYX_ERR(1, 55, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_401stream_CDL3OUTSIDE, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 723, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PEP560_update_bases(__pyx_mstate_global->__pyx_tuple[2]); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 60, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDL3OUTSIDE, __pyx_t_2) < 0) __PYX_ERR(3, 723, __pyx_L1_error)
+  __pyx_t_3 = __Pyx_CalculateMetaclass(NULL, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 60, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = __Pyx_Py3MetaclassPrepare(__pyx_t_3, __pyx_t_2, __pyx_mstate_global->__pyx_n_u_MA_Type, __pyx_mstate_global->__pyx_n_u_MA_Type, (PyObject *) NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, (PyObject *) NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 60, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  if (__pyx_t_2 != __pyx_mstate_global->__pyx_tuple[2]) {
+    if (unlikely((PyDict_SetItemString(__pyx_t_4, "__orig_bases__", __pyx_mstate_global->__pyx_tuple[2]) < 0))) __PYX_ERR(1, 60, __pyx_L1_error)
+  }
+
+  __pyx_t_6 = NULL;
+  __Pyx_INCREF(__pyx_builtin_range);
+  __pyx_t_7 = __pyx_builtin_range; 
+  __pyx_t_8 = 1;
+  {
+    PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_mstate_global->__pyx_int_9};
+    __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_7, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+    if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 61, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+  }
+  if ((likely(PyTuple_CheckExact(__pyx_t_5))) || (PyList_CheckExact(__pyx_t_5))) {
+    PyObject* sequence = __pyx_t_5;
+    Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
+    if (unlikely(size != 9)) {
+      if (size > 9) __Pyx_RaiseTooManyValuesError(9);
+      else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
+      __PYX_ERR(1, 61, __pyx_L1_error)
+    }
+    #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+    if (likely(PyTuple_CheckExact(sequence))) {
+      __pyx_t_7 = PyTuple_GET_ITEM(sequence, 0);
+      __Pyx_INCREF(__pyx_t_7);
+      __pyx_t_6 = PyTuple_GET_ITEM(sequence, 1);
+      __Pyx_INCREF(__pyx_t_6);
+      __pyx_t_9 = PyTuple_GET_ITEM(sequence, 2);
+      __Pyx_INCREF(__pyx_t_9);
+      __pyx_t_10 = PyTuple_GET_ITEM(sequence, 3);
+      __Pyx_INCREF(__pyx_t_10);
+      __pyx_t_11 = PyTuple_GET_ITEM(sequence, 4);
+      __Pyx_INCREF(__pyx_t_11);
+      __pyx_t_12 = PyTuple_GET_ITEM(sequence, 5);
+      __Pyx_INCREF(__pyx_t_12);
+      __pyx_t_13 = PyTuple_GET_ITEM(sequence, 6);
+      __Pyx_INCREF(__pyx_t_13);
+      __pyx_t_14 = PyTuple_GET_ITEM(sequence, 7);
+      __Pyx_INCREF(__pyx_t_14);
+      __pyx_t_15 = PyTuple_GET_ITEM(sequence, 8);
+      __Pyx_INCREF(__pyx_t_15);
+    } else {
+      __pyx_t_7 = __Pyx_PyList_GetItemRef(sequence, 0);
+      if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 61, __pyx_L1_error)
+      __Pyx_XGOTREF(__pyx_t_7);
+      __pyx_t_6 = __Pyx_PyList_GetItemRef(sequence, 1);
+      if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 61, __pyx_L1_error)
+      __Pyx_XGOTREF(__pyx_t_6);
+      __pyx_t_9 = __Pyx_PyList_GetItemRef(sequence, 2);
+      if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 61, __pyx_L1_error)
+      __Pyx_XGOTREF(__pyx_t_9);
+      __pyx_t_10 = __Pyx_PyList_GetItemRef(sequence, 3);
+      if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 61, __pyx_L1_error)
+      __Pyx_XGOTREF(__pyx_t_10);
+      __pyx_t_11 = __Pyx_PyList_GetItemRef(sequence, 4);
+      if (unlikely(!__pyx_t_11)) __PYX_ERR(1, 61, __pyx_L1_error)
+      __Pyx_XGOTREF(__pyx_t_11);
+      __pyx_t_12 = __Pyx_PyList_GetItemRef(sequence, 5);
+      if (unlikely(!__pyx_t_12)) __PYX_ERR(1, 61, __pyx_L1_error)
+      __Pyx_XGOTREF(__pyx_t_12);
+      __pyx_t_13 = __Pyx_PyList_GetItemRef(sequence, 6);
+      if (unlikely(!__pyx_t_13)) __PYX_ERR(1, 61, __pyx_L1_error)
+      __Pyx_XGOTREF(__pyx_t_13);
+      __pyx_t_14 = __Pyx_PyList_GetItemRef(sequence, 7);
+      if (unlikely(!__pyx_t_14)) __PYX_ERR(1, 61, __pyx_L1_error)
+      __Pyx_XGOTREF(__pyx_t_14);
+      __pyx_t_15 = __Pyx_PyList_GetItemRef(sequence, 8);
+      if (unlikely(!__pyx_t_15)) __PYX_ERR(1, 61, __pyx_L1_error)
+      __Pyx_XGOTREF(__pyx_t_15);
+    }
+    #else
+    {
+      Py_ssize_t i;
+      PyObject** temps[9] = {&__pyx_t_7,&__pyx_t_6,&__pyx_t_9,&__pyx_t_10,&__pyx_t_11,&__pyx_t_12,&__pyx_t_13,&__pyx_t_14,&__pyx_t_15};
+      for (i=0; i < 9; i++) {
+        PyObject* item = __Pyx_PySequence_ITEM(sequence, i); if (unlikely(!item)) __PYX_ERR(1, 61, __pyx_L1_error)
+        __Pyx_GOTREF(item);
+        *(temps[i]) = item;
+      }
+    }
+    #endif
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  } else {
+    Py_ssize_t index = -1;
+    PyObject** temps[9] = {&__pyx_t_7,&__pyx_t_6,&__pyx_t_9,&__pyx_t_10,&__pyx_t_11,&__pyx_t_12,&__pyx_t_13,&__pyx_t_14,&__pyx_t_15};
+    __pyx_t_16 = PyObject_GetIter(__pyx_t_5); if (unlikely(!__pyx_t_16)) __PYX_ERR(1, 61, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_16);
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __pyx_t_17 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_16);
+    for (index=0; index < 9; index++) {
+      PyObject* item = __pyx_t_17(__pyx_t_16); if (unlikely(!item)) goto __pyx_L2_unpacking_failed;
+      __Pyx_GOTREF(item);
+      *(temps[index]) = item;
+    }
+    if (__Pyx_IternextUnpackEndCheck(__pyx_t_17(__pyx_t_16), 9) < (0)) __PYX_ERR(1, 61, __pyx_L1_error)
+    __pyx_t_17 = NULL;
+    __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
+    goto __pyx_L3_unpacking_done;
+    __pyx_L2_unpacking_failed:;
+    __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
+    __pyx_t_17 = NULL;
+    if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
+    __PYX_ERR(1, 61, __pyx_L1_error)
+    __pyx_L3_unpacking_done:;
+  }
+  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_SMA, __pyx_t_7) < (0)) __PYX_ERR(1, 61, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_EMA, __pyx_t_6) < (0)) __PYX_ERR(1, 61, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_WMA, __pyx_t_9) < (0)) __PYX_ERR(1, 61, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_DEMA, __pyx_t_10) < (0)) __PYX_ERR(1, 61, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_TEMA, __pyx_t_11) < (0)) __PYX_ERR(1, 61, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_TRIMA, __pyx_t_12) < (0)) __PYX_ERR(1, 61, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
+  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_KAMA, __pyx_t_13) < (0)) __PYX_ERR(1, 61, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_MAMA, __pyx_t_14) < (0)) __PYX_ERR(1, 61, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
+  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_T3, __pyx_t_15) < (0)) __PYX_ERR(1, 61, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
+
+  __pyx_t_5 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_7MA_Type_1__init__, 0, __pyx_mstate_global->__pyx_n_u_MA_Type___init, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[3])); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 63, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_init, __pyx_t_5) < (0)) __PYX_ERR(1, 63, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+  __pyx_t_5 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_7MA_Type_3__getitem__, 0, __pyx_mstate_global->__pyx_n_u_MA_Type___getitem, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[4])); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 76, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_getitem, __pyx_t_5) < (0)) __PYX_ERR(1, 76, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+  __pyx_t_5 = __Pyx_Py3ClassCreate(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_MA_Type, __pyx_t_2, __pyx_t_4, NULL, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 60, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_MA_Type, __pyx_t_5) < (0)) __PYX_ERR(1, 60, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_403stream_CDL3STARSINSOUTH, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 759, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDL3STARSINSOUTH, __pyx_t_2) < 0) __PYX_ERR(3, 759, __pyx_L1_error)
+  __pyx_t_3 = NULL;
+  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_MA_Type); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 79, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_8 = 1;
+  {
+    PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL};
+    __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_8, (1-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 79, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+  }
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_MA_Type, __pyx_t_2) < (0)) __PYX_ERR(1, 79, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_405stream_CDL3WHITESOLDIERS, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 795, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 81, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDL3WHITESOLDIERS, __pyx_t_2) < 0) __PYX_ERR(3, 795, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_NONE, __pyx_mstate_global->__pyx_int_neg_1) < (0)) __PYX_ERR(1, 81, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ta_func_unst_ids, __pyx_t_2) < (0)) __PYX_ERR(1, 81, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_407stream_CDLABANDONEDBABY, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 831, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLABANDONEDBABY, __pyx_t_2) < 0) __PYX_ERR(3, 831, __pyx_L1_error)
+  __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0);
+  __pyx_t_2 = __pyx_mstate_global->__pyx_int_0;
+  __pyx_t_4 = __Pyx_PyList_Pack(24, __pyx_mstate_global->__pyx_n_u_ADX, __pyx_mstate_global->__pyx_n_u_ADXR, __pyx_mstate_global->__pyx_n_u_ATR, __pyx_mstate_global->__pyx_n_u_CMO, __pyx_mstate_global->__pyx_n_u_DX, __pyx_mstate_global->__pyx_n_u_EMA, __pyx_mstate_global->__pyx_n_u_HT_DCPERIOD, __pyx_mstate_global->__pyx_n_u_HT_DCPHASE, __pyx_mstate_global->__pyx_n_u_HT_PHASOR, __pyx_mstate_global->__pyx_n_u_HT_SINE, __pyx_mstate_global->__pyx_n_u_HT_TRENDLINE, __pyx_mstate_global->__pyx_n_u_HT_TRENDMODE, __pyx_mstate_global->__pyx_n_u_KAMA, __pyx_mstate_global->__pyx_n_u_MAMA, __pyx_mstate_global->__pyx_n_u_MFI, __pyx_mstate_global->__pyx_n_u_MINUS_DI, __pyx_mstate_global->__pyx_n_u_MINUS_DM, __pyx_mstate_global->__pyx_n_u_NATR, __pyx_mstate_global->__pyx_n_u_PLUS_DI, __pyx_mstate_global->__pyx_n_u_PLUS_DM, __pyx_mstate_global->__pyx_n_u_RSI, __pyx_mstate_global->__pyx_n_u_STOCHRSI, __pyx_mstate_global->__pyx_n_u_T3, __pyx_mstate_global->__pyx_n_u_ALL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 82, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_3 = __pyx_t_4; __Pyx_INCREF(__pyx_t_3);
+  __pyx_t_18 = 0;
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  for (;;) {
+    if (__pyx_t_18 >= 24) break;
+    __pyx_t_4 = __Pyx_PyList_GetItemRef(__pyx_t_3, __pyx_t_18);
+    ++__pyx_t_18;
+    if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 82, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_name, __pyx_t_4) < (0)) __PYX_ERR(1, 82, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_i, __pyx_t_2) < (0)) __PYX_ERR(1, 82, __pyx_L1_error)
+    __pyx_t_4 = __Pyx_PyLong_AddObjC(__pyx_t_2, __pyx_mstate_global->__pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 82, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_2);
+    __pyx_t_2 = __pyx_t_4;
+    __pyx_t_4 = 0;
+
+    __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_i); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 88, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_ta_func_unst_ids); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 88, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __Pyx_GetModuleGlobalName(__pyx_t_15, __pyx_mstate_global->__pyx_n_u_name); if (unlikely(!__pyx_t_15)) __PYX_ERR(1, 88, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_15);
+    if (unlikely((PyObject_SetItem(__pyx_t_5, __pyx_t_15, __pyx_t_4) < 0))) __PYX_ERR(1, 88, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+  }
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_409stream_CDLADVANCEBLOCK, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 869, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_7_ta_set_unstable_period, 0, __pyx_mstate_global->__pyx_n_u_ta_set_unstable_period, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[5])); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 90, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLADVANCEBLOCK, __pyx_t_2) < 0) __PYX_ERR(3, 869, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ta_set_unstable_period, __pyx_t_2) < (0)) __PYX_ERR(1, 90, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_411stream_CDLBELTHOLD, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 905, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_9_ta_get_unstable_period, 0, __pyx_mstate_global->__pyx_n_u_ta_get_unstable_period, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[6])); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 96, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLBELTHOLD, __pyx_t_2) < 0) __PYX_ERR(3, 905, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ta_get_unstable_period, __pyx_t_2) < (0)) __PYX_ERR(1, 96, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_413stream_CDLBREAKAWAY, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 941, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_11_ta_set_compatibility, 0, __pyx_mstate_global->__pyx_n_u_ta_set_compatibility, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[7])); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 102, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLBREAKAWAY, __pyx_t_2) < 0) __PYX_ERR(3, 941, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ta_set_compatibility, __pyx_t_2) < (0)) __PYX_ERR(1, 102, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_415stream_CDLCLOSINGMARUBOZU, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 977, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_13_ta_get_compatibility, 0, __pyx_mstate_global->__pyx_n_u_ta_get_compatibility, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[8])); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 107, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLCLOSINGMARUBOZU, __pyx_t_2) < 0) __PYX_ERR(3, 977, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ta_get_compatibility, __pyx_t_2) < (0)) __PYX_ERR(1, 107, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_417stream_CDLCONCEALBABYSWALL, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1013, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PEP560_update_bases(__pyx_mstate_global->__pyx_tuple[4]); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 112, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLCONCEALBABYSWALL, __pyx_t_2) < 0) __PYX_ERR(3, 1013, __pyx_L1_error)
+  __pyx_t_3 = __Pyx_CalculateMetaclass(NULL, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 112, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = __Pyx_Py3MetaclassPrepare(__pyx_t_3, __pyx_t_2, __pyx_mstate_global->__pyx_n_u_CandleSettingType, __pyx_mstate_global->__pyx_n_u_CandleSettingType, (PyObject *) NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, (PyObject *) NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 112, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  if (__pyx_t_2 != __pyx_mstate_global->__pyx_tuple[4]) {
+    if (unlikely((PyDict_SetItemString(__pyx_t_4, "__orig_bases__", __pyx_mstate_global->__pyx_tuple[4]) < 0))) __PYX_ERR(1, 112, __pyx_L1_error)
+  }
+
+  __pyx_t_5 = NULL;
+  __Pyx_INCREF(__pyx_builtin_range);
+  __pyx_t_14 = __pyx_builtin_range; 
+  __pyx_t_8 = 1;
+  {
+    PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_mstate_global->__pyx_int_12};
+    __pyx_t_15 = __Pyx_PyObject_FastCall(__pyx_t_14, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
+    if (unlikely(!__pyx_t_15)) __PYX_ERR(1, 115, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_15);
+  }
+  if ((likely(PyTuple_CheckExact(__pyx_t_15))) || (PyList_CheckExact(__pyx_t_15))) {
+    PyObject* sequence = __pyx_t_15;
+    Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
+    if (unlikely(size != 12)) {
+      if (size > 12) __Pyx_RaiseTooManyValuesError(12);
+      else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
+      __PYX_ERR(1, 113, __pyx_L1_error)
+    }
+    #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+    if (likely(PyTuple_CheckExact(sequence))) {
+      __pyx_t_14 = PyTuple_GET_ITEM(sequence, 0);
+      __Pyx_INCREF(__pyx_t_14);
+      __pyx_t_5 = PyTuple_GET_ITEM(sequence, 1);
+      __Pyx_INCREF(__pyx_t_5);
+      __pyx_t_13 = PyTuple_GET_ITEM(sequence, 2);
+      __Pyx_INCREF(__pyx_t_13);
+      __pyx_t_12 = PyTuple_GET_ITEM(sequence, 3);
+      __Pyx_INCREF(__pyx_t_12);
+      __pyx_t_11 = PyTuple_GET_ITEM(sequence, 4);
+      __Pyx_INCREF(__pyx_t_11);
+      __pyx_t_10 = PyTuple_GET_ITEM(sequence, 5);
+      __Pyx_INCREF(__pyx_t_10);
+      __pyx_t_9 = PyTuple_GET_ITEM(sequence, 6);
+      __Pyx_INCREF(__pyx_t_9);
+      __pyx_t_6 = PyTuple_GET_ITEM(sequence, 7);
+      __Pyx_INCREF(__pyx_t_6);
+      __pyx_t_7 = PyTuple_GET_ITEM(sequence, 8);
+      __Pyx_INCREF(__pyx_t_7);
+      __pyx_t_16 = PyTuple_GET_ITEM(sequence, 9);
+      __Pyx_INCREF(__pyx_t_16);
+      __pyx_t_19 = PyTuple_GET_ITEM(sequence, 10);
+      __Pyx_INCREF(__pyx_t_19);
+      __pyx_t_20 = PyTuple_GET_ITEM(sequence, 11);
+      __Pyx_INCREF(__pyx_t_20);
+    } else {
+      __pyx_t_14 = __Pyx_PyList_GetItemRef(sequence, 0);
+      if (unlikely(!__pyx_t_14)) __PYX_ERR(1, 113, __pyx_L1_error)
+      __Pyx_XGOTREF(__pyx_t_14);
+      __pyx_t_5 = __Pyx_PyList_GetItemRef(sequence, 1);
+      if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 113, __pyx_L1_error)
+      __Pyx_XGOTREF(__pyx_t_5);
+      __pyx_t_13 = __Pyx_PyList_GetItemRef(sequence, 2);
+      if (unlikely(!__pyx_t_13)) __PYX_ERR(1, 113, __pyx_L1_error)
+      __Pyx_XGOTREF(__pyx_t_13);
+      __pyx_t_12 = __Pyx_PyList_GetItemRef(sequence, 3);
+      if (unlikely(!__pyx_t_12)) __PYX_ERR(1, 113, __pyx_L1_error)
+      __Pyx_XGOTREF(__pyx_t_12);
+      __pyx_t_11 = __Pyx_PyList_GetItemRef(sequence, 4);
+      if (unlikely(!__pyx_t_11)) __PYX_ERR(1, 113, __pyx_L1_error)
+      __Pyx_XGOTREF(__pyx_t_11);
+      __pyx_t_10 = __Pyx_PyList_GetItemRef(sequence, 5);
+      if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 113, __pyx_L1_error)
+      __Pyx_XGOTREF(__pyx_t_10);
+      __pyx_t_9 = __Pyx_PyList_GetItemRef(sequence, 6);
+      if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 113, __pyx_L1_error)
+      __Pyx_XGOTREF(__pyx_t_9);
+      __pyx_t_6 = __Pyx_PyList_GetItemRef(sequence, 7);
+      if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 113, __pyx_L1_error)
+      __Pyx_XGOTREF(__pyx_t_6);
+      __pyx_t_7 = __Pyx_PyList_GetItemRef(sequence, 8);
+      if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 113, __pyx_L1_error)
+      __Pyx_XGOTREF(__pyx_t_7);
+      __pyx_t_16 = __Pyx_PyList_GetItemRef(sequence, 9);
+      if (unlikely(!__pyx_t_16)) __PYX_ERR(1, 113, __pyx_L1_error)
+      __Pyx_XGOTREF(__pyx_t_16);
+      __pyx_t_19 = __Pyx_PyList_GetItemRef(sequence, 10);
+      if (unlikely(!__pyx_t_19)) __PYX_ERR(1, 113, __pyx_L1_error)
+      __Pyx_XGOTREF(__pyx_t_19);
+      __pyx_t_20 = __Pyx_PyList_GetItemRef(sequence, 11);
+      if (unlikely(!__pyx_t_20)) __PYX_ERR(1, 113, __pyx_L1_error)
+      __Pyx_XGOTREF(__pyx_t_20);
+    }
+    #else
+    {
+      Py_ssize_t i;
+      PyObject** temps[12] = {&__pyx_t_14,&__pyx_t_5,&__pyx_t_13,&__pyx_t_12,&__pyx_t_11,&__pyx_t_10,&__pyx_t_9,&__pyx_t_6,&__pyx_t_7,&__pyx_t_16,&__pyx_t_19,&__pyx_t_20};
+      for (i=0; i < 12; i++) {
+        PyObject* item = __Pyx_PySequence_ITEM(sequence, i); if (unlikely(!item)) __PYX_ERR(1, 113, __pyx_L1_error)
+        __Pyx_GOTREF(item);
+        *(temps[i]) = item;
+      }
+    }
+    #endif
+    __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
+  } else {
+    Py_ssize_t index = -1;
+    PyObject** temps[12] = {&__pyx_t_14,&__pyx_t_5,&__pyx_t_13,&__pyx_t_12,&__pyx_t_11,&__pyx_t_10,&__pyx_t_9,&__pyx_t_6,&__pyx_t_7,&__pyx_t_16,&__pyx_t_19,&__pyx_t_20};
+    __pyx_t_21 = PyObject_GetIter(__pyx_t_15); if (unlikely(!__pyx_t_21)) __PYX_ERR(1, 113, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_21);
+    __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
+    __pyx_t_17 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_21);
+    for (index=0; index < 12; index++) {
+      PyObject* item = __pyx_t_17(__pyx_t_21); if (unlikely(!item)) goto __pyx_L7_unpacking_failed;
+      __Pyx_GOTREF(item);
+      *(temps[index]) = item;
+    }
+    if (__Pyx_IternextUnpackEndCheck(__pyx_t_17(__pyx_t_21), 12) < (0)) __PYX_ERR(1, 113, __pyx_L1_error)
+    __pyx_t_17 = NULL;
+    __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
+    goto __pyx_L8_unpacking_done;
+    __pyx_L7_unpacking_failed:;
+    __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
+    __pyx_t_17 = NULL;
+    if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
+    __PYX_ERR(1, 113, __pyx_L1_error)
+    __pyx_L8_unpacking_done:;
+  }
+
+  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_BodyLong, __pyx_t_14) < (0)) __PYX_ERR(1, 113, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
+  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_BodyVeryLong, __pyx_t_5) < (0)) __PYX_ERR(1, 113, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_BodyShort, __pyx_t_13) < (0)) __PYX_ERR(1, 113, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_BodyDoji, __pyx_t_12) < (0)) __PYX_ERR(1, 113, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
+  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_ShadowLong, __pyx_t_11) < (0)) __PYX_ERR(1, 113, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_ShadowVeryLong, __pyx_t_10) < (0)) __PYX_ERR(1, 113, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_ShadowShort, __pyx_t_9) < (0)) __PYX_ERR(1, 114, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_ShadowVeryShort, __pyx_t_6) < (0)) __PYX_ERR(1, 114, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_Near, __pyx_t_7) < (0)) __PYX_ERR(1, 114, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_Far, __pyx_t_16) < (0)) __PYX_ERR(1, 114, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
+  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_Equal, __pyx_t_19) < (0)) __PYX_ERR(1, 114, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
+  if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_AllCandleSettings, __pyx_t_20) < (0)) __PYX_ERR(1, 114, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+
+  __pyx_t_15 = __Pyx_Py3ClassCreate(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_CandleSettingType, __pyx_t_2, __pyx_t_4, NULL, 0, 1); if (unlikely(!__pyx_t_15)) __PYX_ERR(1, 112, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_15);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CandleSettingType, __pyx_t_15) < (0)) __PYX_ERR(1, 112, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_419stream_CDLCOUNTERATTACK, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1049, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLCOUNTERATTACK, __pyx_t_2) < 0) __PYX_ERR(3, 1049, __pyx_L1_error)
+  __pyx_t_3 = NULL;
+  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_CandleSettingType); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 117, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_8 = 1;
+  {
+    PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL};
+    __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+__pyx_t_8, (1-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 117, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+  }
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CandleSettingType, __pyx_t_2) < (0)) __PYX_ERR(1, 117, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_421stream_CDLDARKCLOUDCOVER, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1085, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PEP560_update_bases(__pyx_mstate_global->__pyx_tuple[6]); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 119, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLDARKCLOUDCOVER, __pyx_t_2) < 0) __PYX_ERR(3, 1085, __pyx_L1_error)
+  __pyx_t_4 = __Pyx_CalculateMetaclass(NULL, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 119, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_4, __pyx_t_2, __pyx_mstate_global->__pyx_n_u_RangeType, __pyx_mstate_global->__pyx_n_u_RangeType, (PyObject *) NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, (PyObject *) NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 119, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__pyx_t_2 != __pyx_mstate_global->__pyx_tuple[6]) {
+    if (unlikely((PyDict_SetItemString(__pyx_t_3, "__orig_bases__", __pyx_mstate_global->__pyx_tuple[6]) < 0))) __PYX_ERR(1, 119, __pyx_L1_error)
+  }
+
+  __pyx_t_20 = NULL;
+  __Pyx_INCREF(__pyx_builtin_range);
+  __pyx_t_19 = __pyx_builtin_range; 
+  __pyx_t_8 = 1;
+  {
+    PyObject *__pyx_callargs[2] = {__pyx_t_20, __pyx_mstate_global->__pyx_int_3};
+    __pyx_t_15 = __Pyx_PyObject_FastCall(__pyx_t_19, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+    __Pyx_XDECREF(__pyx_t_20); __pyx_t_20 = 0;
+    __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
+    if (unlikely(!__pyx_t_15)) __PYX_ERR(1, 120, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_15);
+  }
+  if ((likely(PyTuple_CheckExact(__pyx_t_15))) || (PyList_CheckExact(__pyx_t_15))) {
+    PyObject* sequence = __pyx_t_15;
+    Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
+    if (unlikely(size != 3)) {
+      if (size > 3) __Pyx_RaiseTooManyValuesError(3);
+      else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
+      __PYX_ERR(1, 120, __pyx_L1_error)
+    }
+    #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+    if (likely(PyTuple_CheckExact(sequence))) {
+      __pyx_t_19 = PyTuple_GET_ITEM(sequence, 0);
+      __Pyx_INCREF(__pyx_t_19);
+      __pyx_t_20 = PyTuple_GET_ITEM(sequence, 1);
+      __Pyx_INCREF(__pyx_t_20);
+      __pyx_t_16 = PyTuple_GET_ITEM(sequence, 2);
+      __Pyx_INCREF(__pyx_t_16);
+    } else {
+      __pyx_t_19 = __Pyx_PyList_GetItemRef(sequence, 0);
+      if (unlikely(!__pyx_t_19)) __PYX_ERR(1, 120, __pyx_L1_error)
+      __Pyx_XGOTREF(__pyx_t_19);
+      __pyx_t_20 = __Pyx_PyList_GetItemRef(sequence, 1);
+      if (unlikely(!__pyx_t_20)) __PYX_ERR(1, 120, __pyx_L1_error)
+      __Pyx_XGOTREF(__pyx_t_20);
+      __pyx_t_16 = __Pyx_PyList_GetItemRef(sequence, 2);
+      if (unlikely(!__pyx_t_16)) __PYX_ERR(1, 120, __pyx_L1_error)
+      __Pyx_XGOTREF(__pyx_t_16);
+    }
+    #else
+    __pyx_t_19 = __Pyx_PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_19)) __PYX_ERR(1, 120, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_19);
+    __pyx_t_20 = __Pyx_PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_20)) __PYX_ERR(1, 120, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_20);
+    __pyx_t_16 = __Pyx_PySequence_ITEM(sequence, 2); if (unlikely(!__pyx_t_16)) __PYX_ERR(1, 120, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_16);
+    #endif
+    __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
+  } else {
+    Py_ssize_t index = -1;
+    __pyx_t_7 = PyObject_GetIter(__pyx_t_15); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 120, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
+    __pyx_t_17 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_7);
+    index = 0; __pyx_t_19 = __pyx_t_17(__pyx_t_7); if (unlikely(!__pyx_t_19)) goto __pyx_L9_unpacking_failed;
+    __Pyx_GOTREF(__pyx_t_19);
+    index = 1; __pyx_t_20 = __pyx_t_17(__pyx_t_7); if (unlikely(!__pyx_t_20)) goto __pyx_L9_unpacking_failed;
+    __Pyx_GOTREF(__pyx_t_20);
+    index = 2; __pyx_t_16 = __pyx_t_17(__pyx_t_7); if (unlikely(!__pyx_t_16)) goto __pyx_L9_unpacking_failed;
+    __Pyx_GOTREF(__pyx_t_16);
+    if (__Pyx_IternextUnpackEndCheck(__pyx_t_17(__pyx_t_7), 3) < (0)) __PYX_ERR(1, 120, __pyx_L1_error)
+    __pyx_t_17 = NULL;
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+    goto __pyx_L10_unpacking_done;
+    __pyx_L9_unpacking_failed:;
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+    __pyx_t_17 = NULL;
+    if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
+    __PYX_ERR(1, 120, __pyx_L1_error)
+    __pyx_L10_unpacking_done:;
+  }
+  if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_RealBody, __pyx_t_19) < (0)) __PYX_ERR(1, 120, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
+  if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_HighLow, __pyx_t_20) < (0)) __PYX_ERR(1, 120, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+  if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_Shadows, __pyx_t_16) < (0)) __PYX_ERR(1, 120, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
+
+  __pyx_t_15 = __Pyx_Py3ClassCreate(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_RangeType, __pyx_t_2, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_15)) __PYX_ERR(1, 119, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_15);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_RangeType, __pyx_t_15) < (0)) __PYX_ERR(1, 119, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_423stream_CDLDOJI, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1123, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLDOJI, __pyx_t_2) < 0) __PYX_ERR(3, 1123, __pyx_L1_error)
+  __pyx_t_4 = NULL;
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_RangeType); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 122, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_8 = 1;
+  {
+    PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL};
+    __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_8, (1-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 122, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+  }
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_RangeType, __pyx_t_2) < (0)) __PYX_ERR(1, 122, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_425stream_CDLDOJISTAR, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1159, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_15_ta_set_candle_settings, 0, __pyx_mstate_global->__pyx_n_u_ta_set_candle_settings, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[9])); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 124, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLDOJISTAR, __pyx_t_2) < 0) __PYX_ERR(3, 1159, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ta_set_candle_settings, __pyx_t_2) < (0)) __PYX_ERR(1, 124, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_427stream_CDLDRAGONFLYDOJI, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1195, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_17_ta_restore_candle_default_settings, 0, __pyx_mstate_global->__pyx_n_u_ta_restore_candle_default_setti, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[10])); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 129, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLDRAGONFLYDOJI, __pyx_t_2) < 0) __PYX_ERR(3, 1195, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ta_restore_candle_default_setti, __pyx_t_2) < (0)) __PYX_ERR(1, 129, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_429stream_CDLENGULFING, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1231, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyList_Pack(1, __pyx_mstate_global->__pyx_n_u_nan); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 2, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLENGULFING, __pyx_t_2) < 0) __PYX_ERR(3, 1231, __pyx_L1_error)
+  __pyx_t_3 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_numpy, __pyx_t_2, -1); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 2, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_431stream_CDLEVENINGDOJISTAR, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1267, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_nan); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 2, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLEVENINGDOJISTAR, __pyx_t_2) < 0) __PYX_ERR(3, 1267, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_nan, __pyx_t_2) < (0)) __PYX_ERR(4, 2, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_nan); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 7, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_22 = __Pyx_PyFloat_AsDouble(__pyx_t_3); if (unlikely((__pyx_t_22 == (double)-1) && PyErr_Occurred())) __PYX_ERR(4, 7, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_v_5talib_7_ta_lib_NaN = __pyx_t_22;
+
+  __pyx_t_23 = __pyx_f_5numpy_import_array(); if (unlikely(__pyx_t_23 == ((int)-1))) __PYX_ERR(4, 15, __pyx_L1_error)
+
+  __pyx_t_3 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 144, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_433stream_CDLEVENINGSTAR, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1305, __pyx_L1_error)
+  __pyx_t_2 = PyTuple_Pack(1, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 142, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLEVENINGSTAR, __pyx_t_2) < 0) __PYX_ERR(3, 1305, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_19ACCBANDS, 0, __pyx_mstate_global->__pyx_n_u_ACCBANDS, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[11])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 142, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_2);
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ACCBANDS, __pyx_t_3) < (0)) __PYX_ERR(4, 142, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_21ACOS, 0, __pyx_mstate_global->__pyx_n_u_ACOS, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[12])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 181, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ACOS, __pyx_t_3) < (0)) __PYX_ERR(4, 181, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_23AD, 0, __pyx_mstate_global->__pyx_n_u_AD, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[13])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 210, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_AD, __pyx_t_3) < (0)) __PYX_ERR(4, 210, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_25ADD, 0, __pyx_mstate_global->__pyx_n_u_ADD, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[14])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 242, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ADD, __pyx_t_3) < (0)) __PYX_ERR(4, 242, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_435stream_CDLGAPSIDESIDEWHITE, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1343, __pyx_L1_error)
+  __pyx_t_3 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 275, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_2 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 275, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLGAPSIDESIDEWHITE, __pyx_t_2) < 0) __PYX_ERR(3, 1343, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_437stream_CDLGRAVESTONEDOJI, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1379, __pyx_L1_error)
+  __pyx_t_4 = PyTuple_Pack(2, __pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 273, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_27ADOSC, 0, __pyx_mstate_global->__pyx_n_u_ADOSC, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[15])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 273, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLGRAVESTONEDOJI, __pyx_t_2) < 0) __PYX_ERR(3, 1379, __pyx_L1_error)
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_4);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ADOSC, __pyx_t_2) < (0)) __PYX_ERR(4, 273, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_439stream_CDLHAMMER, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1415, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 310, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLHAMMER, __pyx_t_2) < 0) __PYX_ERR(3, 1415, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_441stream_CDLHANGINGMAN, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1451, __pyx_L1_error)
+  __pyx_t_4 = PyTuple_Pack(1, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 308, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_29ADX, 0, __pyx_mstate_global->__pyx_n_u_ADX, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[16])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 308, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLHANGINGMAN, __pyx_t_2) < 0) __PYX_ERR(3, 1451, __pyx_L1_error)
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_4);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ADX, __pyx_t_2) < (0)) __PYX_ERR(4, 308, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_443stream_CDLHARAMI, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1487, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 343, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLHARAMI, __pyx_t_2) < 0) __PYX_ERR(3, 1487, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_445stream_CDLHARAMICROSS, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1523, __pyx_L1_error)
+  __pyx_t_4 = PyTuple_Pack(1, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 341, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_31ADXR, 0, __pyx_mstate_global->__pyx_n_u_ADXR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[17])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 341, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLHARAMICROSS, __pyx_t_2) < 0) __PYX_ERR(3, 1523, __pyx_L1_error)
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_4);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ADXR, __pyx_t_2) < (0)) __PYX_ERR(4, 341, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_447stream_CDLHIGHWAVE, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1559, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 376, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLHIGHWAVE, __pyx_t_2) < 0) __PYX_ERR(3, 1559, __pyx_L1_error)
+  __pyx_t_4 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 376, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_3 = __Pyx_PyLong_From_int(((int)0)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 376, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+
+  __pyx_t_15 = PyTuple_Pack(3, __pyx_t_2, __pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_15)) __PYX_ERR(4, 374, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_15);
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_33APO, 0, __pyx_mstate_global->__pyx_n_u_APO, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[18])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 374, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_15);
+  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_APO, __pyx_t_3) < (0)) __PYX_ERR(4, 374, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  __pyx_t_3 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 409, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+
+  __pyx_t_15 = PyTuple_Pack(1, __pyx_t_3); if (unlikely(!__pyx_t_15)) __PYX_ERR(4, 407, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_15);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_35AROON, 0, __pyx_mstate_global->__pyx_n_u_AROON, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[19])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 407, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_15);
+  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_AROON, __pyx_t_3) < (0)) __PYX_ERR(4, 407, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  __pyx_t_3 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 444, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+
+  __pyx_t_15 = PyTuple_Pack(1, __pyx_t_3); if (unlikely(!__pyx_t_15)) __PYX_ERR(4, 442, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_15);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_37AROONOSC, 0, __pyx_mstate_global->__pyx_n_u_AROONOSC, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[20])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 442, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_15);
+  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_AROONOSC, __pyx_t_3) < (0)) __PYX_ERR(4, 442, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_39ASIN, 0, __pyx_mstate_global->__pyx_n_u_ASIN, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[21])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 474, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ASIN, __pyx_t_3) < (0)) __PYX_ERR(4, 474, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_41ATAN, 0, __pyx_mstate_global->__pyx_n_u_ATAN, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[22])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 503, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ATAN, __pyx_t_3) < (0)) __PYX_ERR(4, 503, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  __pyx_t_3 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 534, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+
+  __pyx_t_15 = PyTuple_Pack(1, __pyx_t_3); if (unlikely(!__pyx_t_15)) __PYX_ERR(4, 532, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_15);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_43ATR, 0, __pyx_mstate_global->__pyx_n_u_ATR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[23])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 532, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_15);
+  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ATR, __pyx_t_3) < (0)) __PYX_ERR(4, 532, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_45AVGPRICE, 0, __pyx_mstate_global->__pyx_n_u_AVGPRICE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[24])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 565, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_AVGPRICE, __pyx_t_3) < (0)) __PYX_ERR(4, 565, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_449stream_CDLHIKKAKE, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1595, __pyx_L1_error)
+  __pyx_t_3 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 599, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+
+  __pyx_t_15 = PyTuple_Pack(1, __pyx_t_3); if (unlikely(!__pyx_t_15)) __PYX_ERR(4, 597, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_15);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_47AVGDEV, 0, __pyx_mstate_global->__pyx_n_u_AVGDEV, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[25])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 597, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_15);
+  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_AVGDEV, __pyx_t_3) < (0)) __PYX_ERR(4, 597, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  __pyx_t_3 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 630, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_15 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_15)) __PYX_ERR(4, 630, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_15);
+  __pyx_t_4 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 630, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_2 = __Pyx_PyLong_From_int(((int)0)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 630, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLHIKKAKE, __pyx_t_2) < 0) __PYX_ERR(3, 1595, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_451stream_CDLHIKKAKEMOD, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1631, __pyx_L1_error)
+  __pyx_t_16 = PyTuple_Pack(4, __pyx_t_3, __pyx_t_15, __pyx_t_4, __pyx_t_2); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 628, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_16);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_49BBANDS, 0, __pyx_mstate_global->__pyx_n_u_BBANDS, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[26])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 628, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLHIKKAKEMOD, __pyx_t_2) < 0) __PYX_ERR(3, 1631, __pyx_L1_error)
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_16);
+  __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_BBANDS, __pyx_t_2) < (0)) __PYX_ERR(4, 628, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_453stream_CDLHOMINGPIGEON, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1667, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 670, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLHOMINGPIGEON, __pyx_t_2) < 0) __PYX_ERR(3, 1667, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_455stream_CDLIDENTICAL3CROWS, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1703, __pyx_L1_error)
+  __pyx_t_16 = PyTuple_Pack(1, __pyx_t_2); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 668, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_16);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_51BETA, 0, __pyx_mstate_global->__pyx_n_u_BETA, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[27])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 668, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLIDENTICAL3CROWS, __pyx_t_2) < 0) __PYX_ERR(3, 1703, __pyx_L1_error)
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_16);
+  __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_BETA, __pyx_t_2) < (0)) __PYX_ERR(4, 668, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_457stream_CDLINNECK, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1739, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_53BOP, 0, __pyx_mstate_global->__pyx_n_u_BOP, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[28])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 701, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLINNECK, __pyx_t_2) < 0) __PYX_ERR(3, 1739, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_BOP, __pyx_t_2) < (0)) __PYX_ERR(4, 701, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_459stream_CDLINVERTEDHAMMER, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1775, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 735, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLINVERTEDHAMMER, __pyx_t_2) < 0) __PYX_ERR(3, 1775, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_461stream_CDLKICKING, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1811, __pyx_L1_error)
+  __pyx_t_16 = PyTuple_Pack(1, __pyx_t_2); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 733, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_16);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_55CCI, 0, __pyx_mstate_global->__pyx_n_u_CCI, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[29])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 733, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLKICKING, __pyx_t_2) < 0) __PYX_ERR(3, 1811, __pyx_L1_error)
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_16);
+  __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CCI, __pyx_t_2) < (0)) __PYX_ERR(4, 733, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_463stream_CDLKICKINGBYLENGTH, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1847, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_57CDL2CROWS, 0, __pyx_mstate_global->__pyx_n_u_CDL2CROWS, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[30])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 766, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLKICKINGBYLENGTH, __pyx_t_2) < 0) __PYX_ERR(3, 1847, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDL2CROWS, __pyx_t_2) < (0)) __PYX_ERR(4, 766, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_465stream_CDLLADDERBOTTOM, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1883, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_59CDL3BLACKCROWS, 0, __pyx_mstate_global->__pyx_n_u_CDL3BLACKCROWS, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[31])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 798, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLLADDERBOTTOM, __pyx_t_2) < 0) __PYX_ERR(3, 1883, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDL3BLACKCROWS, __pyx_t_2) < (0)) __PYX_ERR(4, 798, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_467stream_CDLLONGLEGGEDDOJI, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1919, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_61CDL3INSIDE, 0, __pyx_mstate_global->__pyx_n_u_CDL3INSIDE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[32])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 830, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLLONGLEGGEDDOJI, __pyx_t_2) < 0) __PYX_ERR(3, 1919, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDL3INSIDE, __pyx_t_2) < (0)) __PYX_ERR(4, 830, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_469stream_CDLLONGLINE, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1955, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_63CDL3LINESTRIKE, 0, __pyx_mstate_global->__pyx_n_u_CDL3LINESTRIKE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[33])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 862, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLLONGLINE, __pyx_t_2) < 0) __PYX_ERR(3, 1955, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDL3LINESTRIKE, __pyx_t_2) < (0)) __PYX_ERR(4, 862, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_471stream_CDLMARUBOZU, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1991, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_65CDL3OUTSIDE, 0, __pyx_mstate_global->__pyx_n_u_CDL3OUTSIDE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[34])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 894, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLMARUBOZU, __pyx_t_2) < 0) __PYX_ERR(3, 1991, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDL3OUTSIDE, __pyx_t_2) < (0)) __PYX_ERR(4, 894, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_473stream_CDLMATCHINGLOW, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 2027, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_67CDL3STARSINSOUTH, 0, __pyx_mstate_global->__pyx_n_u_CDL3STARSINSOUTH, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[35])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 926, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLMATCHINGLOW, __pyx_t_2) < 0) __PYX_ERR(3, 2027, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDL3STARSINSOUTH, __pyx_t_2) < (0)) __PYX_ERR(4, 926, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_475stream_CDLMATHOLD, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 2063, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_69CDL3WHITESOLDIERS, 0, __pyx_mstate_global->__pyx_n_u_CDL3WHITESOLDIERS, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[36])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 958, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLMATHOLD, __pyx_t_2) < 0) __PYX_ERR(3, 2063, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDL3WHITESOLDIERS, __pyx_t_2) < (0)) __PYX_ERR(4, 958, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_477stream_CDLMORNINGDOJISTAR, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 2101, __pyx_L1_error)
+  __pyx_t_2 = PyFloat_FromDouble(((double)0.3)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 992, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLMORNINGDOJISTAR, __pyx_t_2) < 0) __PYX_ERR(3, 2101, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_479stream_CDLMORNINGSTAR, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 2139, __pyx_L1_error)
+  __pyx_t_16 = PyTuple_Pack(1, __pyx_t_2); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 990, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_16);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_71CDLABANDONEDBABY, 0, __pyx_mstate_global->__pyx_n_u_CDLABANDONEDBABY, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[37])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 990, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLMORNINGSTAR, __pyx_t_2) < 0) __PYX_ERR(3, 2139, __pyx_L1_error)
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_16);
+  __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLABANDONEDBABY, __pyx_t_2) < (0)) __PYX_ERR(4, 990, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_481stream_CDLONNECK, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 2177, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_73CDLADVANCEBLOCK, 0, __pyx_mstate_global->__pyx_n_u_CDLADVANCEBLOCK, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[38])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 1024, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLONNECK, __pyx_t_2) < 0) __PYX_ERR(3, 2177, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLADVANCEBLOCK, __pyx_t_2) < (0)) __PYX_ERR(4, 1024, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_483stream_CDLPIERCING, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 2213, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_75CDLBELTHOLD, 0, __pyx_mstate_global->__pyx_n_u_CDLBELTHOLD, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[39])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 1056, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLPIERCING, __pyx_t_2) < 0) __PYX_ERR(3, 2213, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLBELTHOLD, __pyx_t_2) < (0)) __PYX_ERR(4, 1056, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_485stream_CDLRICKSHAWMAN, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 2249, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_77CDLBREAKAWAY, 0, __pyx_mstate_global->__pyx_n_u_CDLBREAKAWAY, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[40])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 1088, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLRICKSHAWMAN, __pyx_t_2) < 0) __PYX_ERR(3, 2249, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLBREAKAWAY, __pyx_t_2) < (0)) __PYX_ERR(4, 1088, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_487stream_CDLRISEFALL3METHODS, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 2285, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_79CDLCLOSINGMARUBOZU, 0, __pyx_mstate_global->__pyx_n_u_CDLCLOSINGMARUBOZU, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[41])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 1120, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLRISEFALL3METHODS, __pyx_t_2) < 0) __PYX_ERR(3, 2285, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLCLOSINGMARUBOZU, __pyx_t_2) < (0)) __PYX_ERR(4, 1120, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_489stream_CDLSEPARATINGLINES, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 2321, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_81CDLCONCEALBABYSWALL, 0, __pyx_mstate_global->__pyx_n_u_CDLCONCEALBABYSWALL, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[42])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 1152, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLSEPARATINGLINES, __pyx_t_2) < 0) __PYX_ERR(3, 2321, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLCONCEALBABYSWALL, __pyx_t_2) < (0)) __PYX_ERR(4, 1152, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_491stream_CDLSHOOTINGSTAR, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 2357, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_83CDLCOUNTERATTACK, 0, __pyx_mstate_global->__pyx_n_u_CDLCOUNTERATTACK, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[43])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 1184, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLSHOOTINGSTAR, __pyx_t_2) < 0) __PYX_ERR(3, 2357, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLCOUNTERATTACK, __pyx_t_2) < (0)) __PYX_ERR(4, 1184, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_493stream_CDLSHORTLINE, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 2393, __pyx_L1_error)
+  __pyx_t_2 = PyFloat_FromDouble(((double)0.5)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 1218, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLSHORTLINE, __pyx_t_2) < 0) __PYX_ERR(3, 2393, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_495stream_CDLSPINNINGTOP, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 2429, __pyx_L1_error)
+  __pyx_t_16 = PyTuple_Pack(1, __pyx_t_2); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 1216, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_16);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_85CDLDARKCLOUDCOVER, 0, __pyx_mstate_global->__pyx_n_u_CDLDARKCLOUDCOVER, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[44])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 1216, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLSPINNINGTOP, __pyx_t_2) < 0) __PYX_ERR(3, 2429, __pyx_L1_error)
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_16);
+  __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLDARKCLOUDCOVER, __pyx_t_2) < (0)) __PYX_ERR(4, 1216, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_497stream_CDLSTALLEDPATTERN, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 2465, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_87CDLDOJI, 0, __pyx_mstate_global->__pyx_n_u_CDLDOJI, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[45])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 1250, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLSTALLEDPATTERN, __pyx_t_2) < 0) __PYX_ERR(3, 2465, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLDOJI, __pyx_t_2) < (0)) __PYX_ERR(4, 1250, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_499stream_CDLSTICKSANDWICH, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 2501, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_89CDLDOJISTAR, 0, __pyx_mstate_global->__pyx_n_u_CDLDOJISTAR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[46])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 1282, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLSTICKSANDWICH, __pyx_t_2) < 0) __PYX_ERR(3, 2501, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLDOJISTAR, __pyx_t_2) < (0)) __PYX_ERR(4, 1282, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_501stream_CDLTAKURI, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 2537, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_91CDLDRAGONFLYDOJI, 0, __pyx_mstate_global->__pyx_n_u_CDLDRAGONFLYDOJI, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[47])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 1314, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLTAKURI, __pyx_t_2) < 0) __PYX_ERR(3, 2537, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLDRAGONFLYDOJI, __pyx_t_2) < (0)) __PYX_ERR(4, 1314, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_503stream_CDLTASUKIGAP, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 2573, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_93CDLENGULFING, 0, __pyx_mstate_global->__pyx_n_u_CDLENGULFING, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[48])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 1346, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLTASUKIGAP, __pyx_t_2) < 0) __PYX_ERR(3, 2573, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLENGULFING, __pyx_t_2) < (0)) __PYX_ERR(4, 1346, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_505stream_CDLTHRUSTING, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 2609, __pyx_L1_error)
+  __pyx_t_2 = PyFloat_FromDouble(((double)0.3)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 1380, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLTHRUSTING, __pyx_t_2) < 0) __PYX_ERR(3, 2609, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_507stream_CDLTRISTAR, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 2645, __pyx_L1_error)
+  __pyx_t_16 = PyTuple_Pack(1, __pyx_t_2); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 1378, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_16);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_95CDLEVENINGDOJISTAR, 0, __pyx_mstate_global->__pyx_n_u_CDLEVENINGDOJISTAR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[49])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 1378, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLTRISTAR, __pyx_t_2) < 0) __PYX_ERR(3, 2645, __pyx_L1_error)
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_16);
+  __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLEVENINGDOJISTAR, __pyx_t_2) < (0)) __PYX_ERR(4, 1378, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_509stream_CDLUNIQUE3RIVER, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 2681, __pyx_L1_error)
+  __pyx_t_2 = PyFloat_FromDouble(((double)0.3)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 1414, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLUNIQUE3RIVER, __pyx_t_2) < 0) __PYX_ERR(3, 2681, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_511stream_CDLUPSIDEGAP2CROWS, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 2717, __pyx_L1_error)
+  __pyx_t_16 = PyTuple_Pack(1, __pyx_t_2); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 1412, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_16);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_97CDLEVENINGSTAR, 0, __pyx_mstate_global->__pyx_n_u_CDLEVENINGSTAR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[50])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 1412, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLUPSIDEGAP2CROWS, __pyx_t_2) < 0) __PYX_ERR(3, 2717, __pyx_L1_error)
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_16);
+  __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLEVENINGSTAR, __pyx_t_2) < (0)) __PYX_ERR(4, 1412, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_513stream_CDLXSIDEGAP3METHODS, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 2753, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_99CDLGAPSIDESIDEWHITE, 0, __pyx_mstate_global->__pyx_n_u_CDLGAPSIDESIDEWHITE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[51])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 1446, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CDLXSIDEGAP3METHODS, __pyx_t_2) < 0) __PYX_ERR(3, 2753, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLGAPSIDESIDEWHITE, __pyx_t_2) < (0)) __PYX_ERR(4, 1446, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_515stream_CEIL, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 2789, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_101CDLGRAVESTONEDOJI, 0, __pyx_mstate_global->__pyx_n_u_CDLGRAVESTONEDOJI, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[52])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 1478, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CEIL, __pyx_t_2) < 0) __PYX_ERR(3, 2789, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLGRAVESTONEDOJI, __pyx_t_2) < (0)) __PYX_ERR(4, 1478, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_517stream_CMO, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 2816, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_103CDLHAMMER, 0, __pyx_mstate_global->__pyx_n_u_CDLHAMMER, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[53])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 1510, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CMO, __pyx_t_2) < 0) __PYX_ERR(3, 2816, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLHAMMER, __pyx_t_2) < (0)) __PYX_ERR(4, 1510, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_519stream_CORREL, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 2845, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_105CDLHANGINGMAN, 0, __pyx_mstate_global->__pyx_n_u_CDLHANGINGMAN, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[54])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 1542, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_CORREL, __pyx_t_2) < 0) __PYX_ERR(3, 2845, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLHANGINGMAN, __pyx_t_2) < (0)) __PYX_ERR(4, 1542, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_521stream_COS, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 2878, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_107CDLHARAMI, 0, __pyx_mstate_global->__pyx_n_u_CDLHARAMI, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[55])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 1574, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_COS, __pyx_t_2) < 0) __PYX_ERR(3, 2878, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLHARAMI, __pyx_t_2) < (0)) __PYX_ERR(4, 1574, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_523stream_COSH, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 2905, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_109CDLHARAMICROSS, 0, __pyx_mstate_global->__pyx_n_u_CDLHARAMICROSS, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[56])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 1606, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_COSH, __pyx_t_2) < 0) __PYX_ERR(3, 2905, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLHARAMICROSS, __pyx_t_2) < (0)) __PYX_ERR(4, 1606, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_525stream_DEMA, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 2932, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_111CDLHIGHWAVE, 0, __pyx_mstate_global->__pyx_n_u_CDLHIGHWAVE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[57])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 1638, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_DEMA, __pyx_t_2) < 0) __PYX_ERR(3, 2932, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLHIGHWAVE, __pyx_t_2) < (0)) __PYX_ERR(4, 1638, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_527stream_DIV, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 2961, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_113CDLHIKKAKE, 0, __pyx_mstate_global->__pyx_n_u_CDLHIKKAKE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[58])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 1670, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_DIV, __pyx_t_2) < 0) __PYX_ERR(3, 2961, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLHIKKAKE, __pyx_t_2) < (0)) __PYX_ERR(4, 1670, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_529stream_DX, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 2992, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_115CDLHIKKAKEMOD, 0, __pyx_mstate_global->__pyx_n_u_CDLHIKKAKEMOD, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[59])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 1702, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_DX, __pyx_t_2) < 0) __PYX_ERR(3, 2992, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLHIKKAKEMOD, __pyx_t_2) < (0)) __PYX_ERR(4, 1702, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_531stream_EMA, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 3027, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_117CDLHOMINGPIGEON, 0, __pyx_mstate_global->__pyx_n_u_CDLHOMINGPIGEON, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[60])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 1734, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_EMA, __pyx_t_2) < 0) __PYX_ERR(3, 3027, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLHOMINGPIGEON, __pyx_t_2) < (0)) __PYX_ERR(4, 1734, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_533stream_EXP, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 3056, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_119CDLIDENTICAL3CROWS, 0, __pyx_mstate_global->__pyx_n_u_CDLIDENTICAL3CROWS, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[61])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 1766, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_EXP, __pyx_t_2) < 0) __PYX_ERR(3, 3056, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLIDENTICAL3CROWS, __pyx_t_2) < (0)) __PYX_ERR(4, 1766, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_535stream_FLOOR, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 3083, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_121CDLINNECK, 0, __pyx_mstate_global->__pyx_n_u_CDLINNECK, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[62])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 1798, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_FLOOR, __pyx_t_2) < 0) __PYX_ERR(3, 3083, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLINNECK, __pyx_t_2) < (0)) __PYX_ERR(4, 1798, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_537stream_HT_DCPERIOD, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 3110, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_123CDLINVERTEDHAMMER, 0, __pyx_mstate_global->__pyx_n_u_CDLINVERTEDHAMMER, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[63])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 1830, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_HT_DCPERIOD, __pyx_t_2) < 0) __PYX_ERR(3, 3110, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLINVERTEDHAMMER, __pyx_t_2) < (0)) __PYX_ERR(4, 1830, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_539stream_HT_DCPHASE, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 3137, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_125CDLKICKING, 0, __pyx_mstate_global->__pyx_n_u_CDLKICKING, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[64])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 1862, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_HT_DCPHASE, __pyx_t_2) < 0) __PYX_ERR(3, 3137, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLKICKING, __pyx_t_2) < (0)) __PYX_ERR(4, 1862, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_541stream_HT_PHASOR, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 3164, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_127CDLKICKINGBYLENGTH, 0, __pyx_mstate_global->__pyx_n_u_CDLKICKINGBYLENGTH, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[65])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 1894, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_HT_PHASOR, __pyx_t_2) < 0) __PYX_ERR(3, 3164, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLKICKINGBYLENGTH, __pyx_t_2) < (0)) __PYX_ERR(4, 1894, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_543stream_HT_SINE, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 3194, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_129CDLLADDERBOTTOM, 0, __pyx_mstate_global->__pyx_n_u_CDLLADDERBOTTOM, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[66])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 1926, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_HT_SINE, __pyx_t_2) < 0) __PYX_ERR(3, 3194, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLLADDERBOTTOM, __pyx_t_2) < (0)) __PYX_ERR(4, 1926, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_545stream_HT_TRENDLINE, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 3224, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_131CDLLONGLEGGEDDOJI, 0, __pyx_mstate_global->__pyx_n_u_CDLLONGLEGGEDDOJI, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[67])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 1958, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_HT_TRENDLINE, __pyx_t_2) < 0) __PYX_ERR(3, 3224, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLLONGLEGGEDDOJI, __pyx_t_2) < (0)) __PYX_ERR(4, 1958, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_547stream_HT_TRENDMODE, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 3251, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_133CDLLONGLINE, 0, __pyx_mstate_global->__pyx_n_u_CDLLONGLINE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[68])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 1990, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_HT_TRENDMODE, __pyx_t_2) < 0) __PYX_ERR(3, 3251, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLLONGLINE, __pyx_t_2) < (0)) __PYX_ERR(4, 1990, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_549stream_KAMA, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 3278, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_135CDLMARUBOZU, 0, __pyx_mstate_global->__pyx_n_u_CDLMARUBOZU, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[69])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 2022, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_KAMA, __pyx_t_2) < 0) __PYX_ERR(3, 3278, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLMARUBOZU, __pyx_t_2) < (0)) __PYX_ERR(4, 2022, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_551stream_LINEARREG, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 3307, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_137CDLMATCHINGLOW, 0, __pyx_mstate_global->__pyx_n_u_CDLMATCHINGLOW, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[70])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 2054, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_LINEARREG, __pyx_t_2) < 0) __PYX_ERR(3, 3307, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLMATCHINGLOW, __pyx_t_2) < (0)) __PYX_ERR(4, 2054, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_553stream_LINEARREG_ANGLE, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 3336, __pyx_L1_error)
+  __pyx_t_2 = PyFloat_FromDouble(((double)0.5)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 2088, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_LINEARREG_ANGLE, __pyx_t_2) < 0) __PYX_ERR(3, 3336, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_555stream_LINEARREG_INTERCEPT, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 3365, __pyx_L1_error)
+  __pyx_t_16 = PyTuple_Pack(1, __pyx_t_2); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 2086, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_16);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_139CDLMATHOLD, 0, __pyx_mstate_global->__pyx_n_u_CDLMATHOLD, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[71])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 2086, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_LINEARREG_INTERCEPT, __pyx_t_2) < 0) __PYX_ERR(3, 3365, __pyx_L1_error)
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_16);
+  __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLMATHOLD, __pyx_t_2) < (0)) __PYX_ERR(4, 2086, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_557stream_LINEARREG_SLOPE, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 3394, __pyx_L1_error)
+  __pyx_t_2 = PyFloat_FromDouble(((double)0.3)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 2122, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_LINEARREG_SLOPE, __pyx_t_2) < 0) __PYX_ERR(3, 3394, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_559stream_LN, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 3423, __pyx_L1_error)
+  __pyx_t_16 = PyTuple_Pack(1, __pyx_t_2); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 2120, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_16);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_141CDLMORNINGDOJISTAR, 0, __pyx_mstate_global->__pyx_n_u_CDLMORNINGDOJISTAR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[72])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 2120, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_LN, __pyx_t_2) < 0) __PYX_ERR(3, 3423, __pyx_L1_error)
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_16);
+  __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLMORNINGDOJISTAR, __pyx_t_2) < (0)) __PYX_ERR(4, 2120, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_561stream_LOG10, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 3450, __pyx_L1_error)
+  __pyx_t_2 = PyFloat_FromDouble(((double)0.3)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 2156, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_LOG10, __pyx_t_2) < 0) __PYX_ERR(3, 3450, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_563stream_MA, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 3477, __pyx_L1_error)
+  __pyx_t_16 = PyTuple_Pack(1, __pyx_t_2); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 2154, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_16);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_143CDLMORNINGSTAR, 0, __pyx_mstate_global->__pyx_n_u_CDLMORNINGSTAR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[73])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 2154, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_MA, __pyx_t_2) < 0) __PYX_ERR(3, 3477, __pyx_L1_error)
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_16);
+  __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLMORNINGSTAR, __pyx_t_2) < (0)) __PYX_ERR(4, 2154, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_565stream_MACD, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 3507, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_145CDLONNECK, 0, __pyx_mstate_global->__pyx_n_u_CDLONNECK, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[74])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 2188, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_MACD, __pyx_t_2) < 0) __PYX_ERR(3, 3507, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLONNECK, __pyx_t_2) < (0)) __PYX_ERR(4, 2188, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_567stream_MACDEXT, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 3544, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_147CDLPIERCING, 0, __pyx_mstate_global->__pyx_n_u_CDLPIERCING, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[75])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 2220, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_MACDEXT, __pyx_t_2) < 0) __PYX_ERR(3, 3544, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLPIERCING, __pyx_t_2) < (0)) __PYX_ERR(4, 2220, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_569stream_MACDFIX, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 3584, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_149CDLRICKSHAWMAN, 0, __pyx_mstate_global->__pyx_n_u_CDLRICKSHAWMAN, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[76])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 2252, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_MACDFIX, __pyx_t_2) < 0) __PYX_ERR(3, 3584, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLRICKSHAWMAN, __pyx_t_2) < (0)) __PYX_ERR(4, 2252, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_571stream_MAMA, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 3619, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_151CDLRISEFALL3METHODS, 0, __pyx_mstate_global->__pyx_n_u_CDLRISEFALL3METHODS, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[77])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 2284, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_MAMA, __pyx_t_2) < 0) __PYX_ERR(3, 3619, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLRISEFALL3METHODS, __pyx_t_2) < (0)) __PYX_ERR(4, 2284, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_573stream_MAVP, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 3652, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_153CDLSEPARATINGLINES, 0, __pyx_mstate_global->__pyx_n_u_CDLSEPARATINGLINES, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[78])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 2316, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_MAVP, __pyx_t_2) < 0) __PYX_ERR(3, 3652, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLSEPARATINGLINES, __pyx_t_2) < (0)) __PYX_ERR(4, 2316, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_575stream_MAX, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 3687, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_155CDLSHOOTINGSTAR, 0, __pyx_mstate_global->__pyx_n_u_CDLSHOOTINGSTAR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[79])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 2348, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_MAX, __pyx_t_2) < 0) __PYX_ERR(3, 3687, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLSHOOTINGSTAR, __pyx_t_2) < (0)) __PYX_ERR(4, 2348, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_577stream_MAXINDEX, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 3716, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_157CDLSHORTLINE, 0, __pyx_mstate_global->__pyx_n_u_CDLSHORTLINE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[80])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 2380, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_MAXINDEX, __pyx_t_2) < 0) __PYX_ERR(3, 3716, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLSHORTLINE, __pyx_t_2) < (0)) __PYX_ERR(4, 2380, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_579stream_MEDPRICE, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 3745, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_159CDLSPINNINGTOP, 0, __pyx_mstate_global->__pyx_n_u_CDLSPINNINGTOP, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[81])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 2412, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_MEDPRICE, __pyx_t_2) < 0) __PYX_ERR(3, 3745, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLSPINNINGTOP, __pyx_t_2) < (0)) __PYX_ERR(4, 2412, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_581stream_MFI, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 3775, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_161CDLSTALLEDPATTERN, 0, __pyx_mstate_global->__pyx_n_u_CDLSTALLEDPATTERN, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[82])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 2444, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_MFI, __pyx_t_2) < 0) __PYX_ERR(3, 3775, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLSTALLEDPATTERN, __pyx_t_2) < (0)) __PYX_ERR(4, 2444, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_583stream_MIDPOINT, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 3813, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_163CDLSTICKSANDWICH, 0, __pyx_mstate_global->__pyx_n_u_CDLSTICKSANDWICH, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[83])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 2476, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_MIDPOINT, __pyx_t_2) < 0) __PYX_ERR(3, 3813, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLSTICKSANDWICH, __pyx_t_2) < (0)) __PYX_ERR(4, 2476, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_585stream_MIDPRICE, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 3842, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_165CDLTAKURI, 0, __pyx_mstate_global->__pyx_n_u_CDLTAKURI, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[84])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 2508, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_MIDPRICE, __pyx_t_2) < 0) __PYX_ERR(3, 3842, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLTAKURI, __pyx_t_2) < (0)) __PYX_ERR(4, 2508, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_587stream_MIN, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 3874, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_167CDLTASUKIGAP, 0, __pyx_mstate_global->__pyx_n_u_CDLTASUKIGAP, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[85])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 2540, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_MIN, __pyx_t_2) < 0) __PYX_ERR(3, 3874, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLTASUKIGAP, __pyx_t_2) < (0)) __PYX_ERR(4, 2540, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_589stream_MININDEX, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 3903, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_169CDLTHRUSTING, 0, __pyx_mstate_global->__pyx_n_u_CDLTHRUSTING, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[86])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 2572, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_MININDEX, __pyx_t_2) < 0) __PYX_ERR(3, 3903, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLTHRUSTING, __pyx_t_2) < (0)) __PYX_ERR(4, 2572, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_591stream_MINMAX, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 3932, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_171CDLTRISTAR, 0, __pyx_mstate_global->__pyx_n_u_CDLTRISTAR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[87])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 2604, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_MINMAX, __pyx_t_2) < 0) __PYX_ERR(3, 3932, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLTRISTAR, __pyx_t_2) < (0)) __PYX_ERR(4, 2604, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_593stream_MINMAXINDEX, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 3964, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_173CDLUNIQUE3RIVER, 0, __pyx_mstate_global->__pyx_n_u_CDLUNIQUE3RIVER, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[88])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 2636, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_MINMAXINDEX, __pyx_t_2) < 0) __PYX_ERR(3, 3964, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLUNIQUE3RIVER, __pyx_t_2) < (0)) __PYX_ERR(4, 2636, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_595stream_MINUS_DI, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 3996, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_175CDLUPSIDEGAP2CROWS, 0, __pyx_mstate_global->__pyx_n_u_CDLUPSIDEGAP2CROWS, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[89])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 2668, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_MINUS_DI, __pyx_t_2) < 0) __PYX_ERR(3, 3996, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLUPSIDEGAP2CROWS, __pyx_t_2) < (0)) __PYX_ERR(4, 2668, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_597stream_MINUS_DM, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 4031, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_177CDLXSIDEGAP3METHODS, 0, __pyx_mstate_global->__pyx_n_u_CDLXSIDEGAP3METHODS, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[90])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 2700, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_MINUS_DM, __pyx_t_2) < 0) __PYX_ERR(3, 4031, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLXSIDEGAP3METHODS, __pyx_t_2) < (0)) __PYX_ERR(4, 2700, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_599stream_MOM, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 4063, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_179CEIL, 0, __pyx_mstate_global->__pyx_n_u_CEIL, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[91])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 2732, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_MOM, __pyx_t_2) < 0) __PYX_ERR(3, 4063, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CEIL, __pyx_t_2) < (0)) __PYX_ERR(4, 2732, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_601stream_MULT, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 4092, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 2763, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_MULT, __pyx_t_2) < 0) __PYX_ERR(3, 4092, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_603stream_NATR, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 4123, __pyx_L1_error)
+  __pyx_t_16 = PyTuple_Pack(1, __pyx_t_2); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 2761, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_16);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_181CMO, 0, __pyx_mstate_global->__pyx_n_u_CMO, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[92])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 2761, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_NATR, __pyx_t_2) < 0) __PYX_ERR(3, 4123, __pyx_L1_error)
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_16);
+  __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CMO, __pyx_t_2) < (0)) __PYX_ERR(4, 2761, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_605stream_OBV, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 4158, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 2794, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_OBV, __pyx_t_2) < 0) __PYX_ERR(3, 4158, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_607stream_PLUS_DI, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 4189, __pyx_L1_error)
+  __pyx_t_16 = PyTuple_Pack(1, __pyx_t_2); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 2792, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_16);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_183CORREL, 0, __pyx_mstate_global->__pyx_n_u_CORREL, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[93])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 2792, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_PLUS_DI, __pyx_t_2) < 0) __PYX_ERR(3, 4189, __pyx_L1_error)
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_16);
+  __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CORREL, __pyx_t_2) < (0)) __PYX_ERR(4, 2792, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_609stream_PLUS_DM, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 4224, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_185COS, 0, __pyx_mstate_global->__pyx_n_u_COS, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[94])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 2825, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_PLUS_DM, __pyx_t_2) < 0) __PYX_ERR(3, 4224, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_COS, __pyx_t_2) < (0)) __PYX_ERR(4, 2825, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_611stream_PPO, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 4256, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_187COSH, 0, __pyx_mstate_global->__pyx_n_u_COSH, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[95])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 2854, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_PPO, __pyx_t_2) < 0) __PYX_ERR(3, 4256, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_COSH, __pyx_t_2) < (0)) __PYX_ERR(4, 2854, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_613stream_ROC, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 4287, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 2885, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_ROC, __pyx_t_2) < 0) __PYX_ERR(3, 4287, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_615stream_ROCP, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 4316, __pyx_L1_error)
+  __pyx_t_16 = PyTuple_Pack(1, __pyx_t_2); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 2883, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_16);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_189DEMA, 0, __pyx_mstate_global->__pyx_n_u_DEMA, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[96])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 2883, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_ROCP, __pyx_t_2) < 0) __PYX_ERR(3, 4316, __pyx_L1_error)
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_16);
+  __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_DEMA, __pyx_t_2) < (0)) __PYX_ERR(4, 2883, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_617stream_ROCR, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 4345, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_191DIV, 0, __pyx_mstate_global->__pyx_n_u_DIV, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[97])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 2914, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_ROCR, __pyx_t_2) < 0) __PYX_ERR(3, 4345, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_DIV, __pyx_t_2) < (0)) __PYX_ERR(4, 2914, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_619stream_ROCR100, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 4374, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 2947, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_ROCR100, __pyx_t_2) < 0) __PYX_ERR(3, 4374, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_621stream_RSI, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 4403, __pyx_L1_error)
+  __pyx_t_16 = PyTuple_Pack(1, __pyx_t_2); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 2945, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_16);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_193DX, 0, __pyx_mstate_global->__pyx_n_u_DX, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[98])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 2945, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_RSI, __pyx_t_2) < 0) __PYX_ERR(3, 4403, __pyx_L1_error)
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_16);
+  __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_DX, __pyx_t_2) < (0)) __PYX_ERR(4, 2945, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_623stream_SAR, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 4432, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 2980, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_SAR, __pyx_t_2) < 0) __PYX_ERR(3, 4432, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_625stream_SAREXT, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 4465, __pyx_L1_error)
+  __pyx_t_16 = PyTuple_Pack(1, __pyx_t_2); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 2978, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_16);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_195EMA, 0, __pyx_mstate_global->__pyx_n_u_EMA, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[99])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 2978, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_SAREXT, __pyx_t_2) < 0) __PYX_ERR(3, 4465, __pyx_L1_error)
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_16);
+  __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_EMA, __pyx_t_2) < (0)) __PYX_ERR(4, 2978, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_627stream_SIN, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 4504, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_197EXP, 0, __pyx_mstate_global->__pyx_n_u_EXP, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[100])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 3009, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_SIN, __pyx_t_2) < 0) __PYX_ERR(3, 4504, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_EXP, __pyx_t_2) < (0)) __PYX_ERR(4, 3009, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_629stream_SINH, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 4531, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_199FLOOR, 0, __pyx_mstate_global->__pyx_n_u_FLOOR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[101])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 3038, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_SINH, __pyx_t_2) < 0) __PYX_ERR(3, 4531, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_FLOOR, __pyx_t_2) < (0)) __PYX_ERR(4, 3038, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_631stream_SMA, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 4558, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_201HT_DCPERIOD, 0, __pyx_mstate_global->__pyx_n_u_HT_DCPERIOD, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[102])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 3067, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_SMA, __pyx_t_2) < 0) __PYX_ERR(3, 4558, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_HT_DCPERIOD, __pyx_t_2) < (0)) __PYX_ERR(4, 3067, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_633stream_SQRT, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 4587, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_203HT_DCPHASE, 0, __pyx_mstate_global->__pyx_n_u_HT_DCPHASE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[103])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 3096, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_SQRT, __pyx_t_2) < 0) __PYX_ERR(3, 4587, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_HT_DCPHASE, __pyx_t_2) < (0)) __PYX_ERR(4, 3096, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_635stream_STDDEV, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 4614, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_205HT_PHASOR, 0, __pyx_mstate_global->__pyx_n_u_HT_PHASOR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[104])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 3125, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_STDDEV, __pyx_t_2) < 0) __PYX_ERR(3, 4614, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_HT_PHASOR, __pyx_t_2) < (0)) __PYX_ERR(4, 3125, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_637stream_STOCH, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 4644, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_207HT_SINE, 0, __pyx_mstate_global->__pyx_n_u_HT_SINE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[105])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 3157, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_STOCH, __pyx_t_2) < 0) __PYX_ERR(3, 4644, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_HT_SINE, __pyx_t_2) < (0)) __PYX_ERR(4, 3157, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_639stream_STOCHF, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 4686, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_209HT_TRENDLINE, 0, __pyx_mstate_global->__pyx_n_u_HT_TRENDLINE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[106])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 3189, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_STOCHF, __pyx_t_2) < 0) __PYX_ERR(3, 4686, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_HT_TRENDLINE, __pyx_t_2) < (0)) __PYX_ERR(4, 3189, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_641stream_STOCHRSI, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 4726, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_211HT_TRENDMODE, 0, __pyx_mstate_global->__pyx_n_u_HT_TRENDMODE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[107])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 3218, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_STOCHRSI, __pyx_t_2) < 0) __PYX_ERR(3, 4726, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_HT_TRENDMODE, __pyx_t_2) < (0)) __PYX_ERR(4, 3218, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_643stream_SUB, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 4761, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 3249, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_SUB, __pyx_t_2) < 0) __PYX_ERR(3, 4761, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_645stream_SUM, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 4792, __pyx_L1_error)
+  __pyx_t_16 = PyTuple_Pack(1, __pyx_t_2); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 3247, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_16);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_213IMI, 0, __pyx_mstate_global->__pyx_n_u_IMI, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[108])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 3247, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_SUM, __pyx_t_2) < 0) __PYX_ERR(3, 4792, __pyx_L1_error)
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_16);
+  __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_IMI, __pyx_t_2) < (0)) __PYX_ERR(4, 3247, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_647stream_T3, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 4821, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 3281, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_T3, __pyx_t_2) < 0) __PYX_ERR(3, 4821, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_649stream_TAN, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 4851, __pyx_L1_error)
+  __pyx_t_16 = PyTuple_Pack(1, __pyx_t_2); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 3279, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_16);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_215KAMA, 0, __pyx_mstate_global->__pyx_n_u_KAMA, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[109])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 3279, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_TAN, __pyx_t_2) < 0) __PYX_ERR(3, 4851, __pyx_L1_error)
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_16);
+  __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_KAMA, __pyx_t_2) < (0)) __PYX_ERR(4, 3279, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_651stream_TANH, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 4878, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 3312, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_TANH, __pyx_t_2) < 0) __PYX_ERR(3, 4878, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_653stream_TEMA, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 4905, __pyx_L1_error)
+  __pyx_t_16 = PyTuple_Pack(1, __pyx_t_2); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 3310, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_16);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_217LINEARREG, 0, __pyx_mstate_global->__pyx_n_u_LINEARREG, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[110])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 3310, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_TEMA, __pyx_t_2) < 0) __PYX_ERR(3, 4905, __pyx_L1_error)
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_16);
+  __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_LINEARREG, __pyx_t_2) < (0)) __PYX_ERR(4, 3310, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_655stream_TRANGE, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 4934, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 3343, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_TRANGE, __pyx_t_2) < 0) __PYX_ERR(3, 4934, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_657stream_TRIMA, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 4967, __pyx_L1_error)
+  __pyx_t_16 = PyTuple_Pack(1, __pyx_t_2); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 3341, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_16);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_219LINEARREG_ANGLE, 0, __pyx_mstate_global->__pyx_n_u_LINEARREG_ANGLE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[111])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 3341, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_TRIMA, __pyx_t_2) < 0) __PYX_ERR(3, 4967, __pyx_L1_error)
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_16);
+  __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_LINEARREG_ANGLE, __pyx_t_2) < (0)) __PYX_ERR(4, 3341, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_659stream_TRIX, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 4996, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 3374, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_TRIX, __pyx_t_2) < 0) __PYX_ERR(3, 4996, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_661stream_TSF, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 5025, __pyx_L1_error)
+  __pyx_t_16 = PyTuple_Pack(1, __pyx_t_2); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 3372, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_16);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_221LINEARREG_INTERCEPT, 0, __pyx_mstate_global->__pyx_n_u_LINEARREG_INTERCEPT, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[112])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 3372, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_TSF, __pyx_t_2) < 0) __PYX_ERR(3, 5025, __pyx_L1_error)
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_16);
+  __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_LINEARREG_INTERCEPT, __pyx_t_2) < (0)) __PYX_ERR(4, 3372, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_663stream_TYPPRICE, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 5054, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 3405, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_TYPPRICE, __pyx_t_2) < 0) __PYX_ERR(3, 5054, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_665stream_ULTOSC, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 5087, __pyx_L1_error)
+  __pyx_t_16 = PyTuple_Pack(1, __pyx_t_2); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 3403, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_16);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_223LINEARREG_SLOPE, 0, __pyx_mstate_global->__pyx_n_u_LINEARREG_SLOPE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[113])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 3403, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_ULTOSC, __pyx_t_2) < 0) __PYX_ERR(3, 5087, __pyx_L1_error)
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_16);
+  __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_LINEARREG_SLOPE, __pyx_t_2) < (0)) __PYX_ERR(4, 3403, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_667stream_VAR, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 5124, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_225LN, 0, __pyx_mstate_global->__pyx_n_u_LN, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[114])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 3434, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_VAR, __pyx_t_2) < 0) __PYX_ERR(3, 5124, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_LN, __pyx_t_2) < (0)) __PYX_ERR(4, 3434, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_669stream_WCLPRICE, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 5154, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_227LOG10, 0, __pyx_mstate_global->__pyx_n_u_LOG10, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[115])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 3463, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_WCLPRICE, __pyx_t_2) < 0) __PYX_ERR(3, 5154, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_LOG10, __pyx_t_2) < (0)) __PYX_ERR(4, 3463, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_671stream_WILLR, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 5187, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 3494, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_WILLR, __pyx_t_2) < 0) __PYX_ERR(3, 5187, __pyx_L1_error)
+  __pyx_t_16 = __Pyx_PyLong_From_int(((int)0)); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 3494, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_16);
+
+  __pyx_t_4 = PyTuple_Pack(2, __pyx_t_2, __pyx_t_16); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 3492, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
+  __pyx_t_16 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_229MA, 0, __pyx_mstate_global->__pyx_n_u_MA, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[116])); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 3492, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_16);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_16, __pyx_t_4);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_MA, __pyx_t_16) < (0)) __PYX_ERR(4, 3492, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
 
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5talib_7_ta_lib_673stream_WMA, NULL, __pyx_n_s_talib__ta_lib); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 5222, __pyx_L1_error)
+  __pyx_t_16 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 3526, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_16);
+  __pyx_t_4 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 3526, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_2 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 3526, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_stream_WMA, __pyx_t_2) < 0) __PYX_ERR(3, 5222, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  __pyx_t_2 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 1, __pyx_L1_error)
+  __pyx_t_15 = PyTuple_Pack(3, __pyx_t_16, __pyx_t_4, __pyx_t_2); if (unlikely(!__pyx_t_15)) __PYX_ERR(4, 3524, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_15);
+  __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_231MACD, 0, __pyx_mstate_global->__pyx_n_u_MACD, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[117])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 3524, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_2) < 0) __PYX_ERR(5, 1, __pyx_L1_error)
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_15);
+  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_MACD, __pyx_t_2) < (0)) __PYX_ERR(4, 3524, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
+  __pyx_t_2 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 3565, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_15 = __Pyx_PyLong_From_int(((int)0)); if (unlikely(!__pyx_t_15)) __PYX_ERR(4, 3565, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_15);
+  __pyx_t_4 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 3565, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_16 = __Pyx_PyLong_From_int(((int)0)); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 3565, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_16);
+  __pyx_t_3 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 3565, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_20 = __Pyx_PyLong_From_int(((int)0)); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 3565, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_20);
 
-  /*--- Wrapped vars code ---*/
+  __pyx_t_19 = PyTuple_Pack(6, __pyx_t_2, __pyx_t_15, __pyx_t_4, __pyx_t_16, __pyx_t_3, __pyx_t_20); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 3563, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_19);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+  __pyx_t_20 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_233MACDEXT, 0, __pyx_mstate_global->__pyx_n_u_MACDEXT, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[118])); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 3563, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_20);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_20, __pyx_t_19);
+  __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_MACDEXT, __pyx_t_20) < (0)) __PYX_ERR(4, 3563, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+
+  __pyx_t_20 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 3607, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_20);
+
+  __pyx_t_19 = PyTuple_Pack(1, __pyx_t_20); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 3605, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_19);
+  __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+  __pyx_t_20 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_235MACDFIX, 0, __pyx_mstate_global->__pyx_n_u_MACDFIX, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[119])); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 3605, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_20);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_20, __pyx_t_19);
+  __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_MACDFIX, __pyx_t_20) < (0)) __PYX_ERR(4, 3605, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+
+  __pyx_t_20 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 3644, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_20);
+  __pyx_t_19 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 3644, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_19);
+
+  __pyx_t_3 = PyTuple_Pack(2, __pyx_t_20, __pyx_t_19); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 3642, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+  __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
+  __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_237MAMA, 0, __pyx_mstate_global->__pyx_n_u_MAMA, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[120])); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 3642, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_19);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_19, __pyx_t_3);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_MAMA, __pyx_t_19) < (0)) __PYX_ERR(4, 3642, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
+
+  __pyx_t_19 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 3679, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_19);
+  __pyx_t_3 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 3679, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_20 = __Pyx_PyLong_From_int(((int)0)); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 3679, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_20);
+
+  __pyx_t_16 = PyTuple_Pack(3, __pyx_t_19, __pyx_t_3, __pyx_t_20); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 3677, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_16);
+  __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+  __pyx_t_20 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_239MAVP, 0, __pyx_mstate_global->__pyx_n_u_MAVP, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[121])); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 3677, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_20);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_20, __pyx_t_16);
+  __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_MAVP, __pyx_t_20) < (0)) __PYX_ERR(4, 3677, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+
+  __pyx_t_20 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 3714, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_20);
+
+  __pyx_t_16 = PyTuple_Pack(1, __pyx_t_20); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 3712, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_16);
+  __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+  __pyx_t_20 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_241MAX, 0, __pyx_mstate_global->__pyx_n_u_MAX, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[122])); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 3712, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_20);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_20, __pyx_t_16);
+  __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_MAX, __pyx_t_20) < (0)) __PYX_ERR(4, 3712, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+
+  __pyx_t_20 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 3745, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_20);
+
+  __pyx_t_16 = PyTuple_Pack(1, __pyx_t_20); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 3743, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_16);
+  __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+  __pyx_t_20 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_243MAXINDEX, 0, __pyx_mstate_global->__pyx_n_u_MAXINDEX, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[123])); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 3743, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_20);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_20, __pyx_t_16);
+  __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_MAXINDEX, __pyx_t_20) < (0)) __PYX_ERR(4, 3743, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+
+  __pyx_t_20 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_245MEDPRICE, 0, __pyx_mstate_global->__pyx_n_u_MEDPRICE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[124])); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 3777, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_20);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_MEDPRICE, __pyx_t_20) < (0)) __PYX_ERR(4, 3777, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+
+  __pyx_t_20 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 3809, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_20);
+
+  __pyx_t_16 = PyTuple_Pack(1, __pyx_t_20); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 3807, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_16);
+  __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+  __pyx_t_20 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_247MFI, 0, __pyx_mstate_global->__pyx_n_u_MFI, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[125])); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 3807, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_20);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_20, __pyx_t_16);
+  __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_MFI, __pyx_t_20) < (0)) __PYX_ERR(4, 3807, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+
+  __pyx_t_20 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 3843, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_20);
+
+  __pyx_t_16 = PyTuple_Pack(1, __pyx_t_20); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 3841, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_16);
+  __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+  __pyx_t_20 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_249MIDPOINT, 0, __pyx_mstate_global->__pyx_n_u_MIDPOINT, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[126])); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 3841, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_20);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_20, __pyx_t_16);
+  __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_MIDPOINT, __pyx_t_20) < (0)) __PYX_ERR(4, 3841, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+
+  __pyx_t_20 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 3874, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_20);
+
+  __pyx_t_16 = PyTuple_Pack(1, __pyx_t_20); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 3872, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_16);
+  __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+  __pyx_t_20 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_251MIDPRICE, 0, __pyx_mstate_global->__pyx_n_u_MIDPRICE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[127])); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 3872, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_20);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_20, __pyx_t_16);
+  __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_MIDPRICE, __pyx_t_20) < (0)) __PYX_ERR(4, 3872, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+
+  __pyx_t_20 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 3906, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_20);
+
+  __pyx_t_16 = PyTuple_Pack(1, __pyx_t_20); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 3904, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_16);
+  __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+  __pyx_t_20 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_253MIN, 0, __pyx_mstate_global->__pyx_n_u_MIN, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[128])); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 3904, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_20);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_20, __pyx_t_16);
+  __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_MIN, __pyx_t_20) < (0)) __PYX_ERR(4, 3904, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+
+  __pyx_t_20 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 3937, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_20);
+
+  __pyx_t_16 = PyTuple_Pack(1, __pyx_t_20); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 3935, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_16);
+  __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+  __pyx_t_20 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_255MININDEX, 0, __pyx_mstate_global->__pyx_n_u_MININDEX, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[129])); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 3935, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_20);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_20, __pyx_t_16);
+  __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_MININDEX, __pyx_t_20) < (0)) __PYX_ERR(4, 3935, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+
+  __pyx_t_20 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 3971, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_20);
+
+  __pyx_t_16 = PyTuple_Pack(1, __pyx_t_20); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 3969, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_16);
+  __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+  __pyx_t_20 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_257MINMAX, 0, __pyx_mstate_global->__pyx_n_u_MINMAX, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[130])); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 3969, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_20);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_20, __pyx_t_16);
+  __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_MINMAX, __pyx_t_20) < (0)) __PYX_ERR(4, 3969, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+
+  __pyx_t_20 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 4005, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_20);
+
+  __pyx_t_16 = PyTuple_Pack(1, __pyx_t_20); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 4003, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_16);
+  __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+  __pyx_t_20 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_259MINMAXINDEX, 0, __pyx_mstate_global->__pyx_n_u_MINMAXINDEX, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[131])); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 4003, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_20);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_20, __pyx_t_16);
+  __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_MINMAXINDEX, __pyx_t_20) < (0)) __PYX_ERR(4, 4003, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+
+  __pyx_t_20 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 4045, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_20);
+
+  __pyx_t_16 = PyTuple_Pack(1, __pyx_t_20); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 4043, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_16);
+  __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+  __pyx_t_20 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_261MINUS_DI, 0, __pyx_mstate_global->__pyx_n_u_MINUS_DI, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[132])); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 4043, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_20);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_20, __pyx_t_16);
+  __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_MINUS_DI, __pyx_t_20) < (0)) __PYX_ERR(4, 4043, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+
+  __pyx_t_20 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 4078, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_20);
+
+  __pyx_t_16 = PyTuple_Pack(1, __pyx_t_20); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 4076, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_16);
+  __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+  __pyx_t_20 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_263MINUS_DM, 0, __pyx_mstate_global->__pyx_n_u_MINUS_DM, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[133])); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 4076, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_20);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_20, __pyx_t_16);
+  __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_MINUS_DM, __pyx_t_20) < (0)) __PYX_ERR(4, 4076, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+
+  __pyx_t_20 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 4110, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_20);
+
+  __pyx_t_16 = PyTuple_Pack(1, __pyx_t_20); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 4108, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_16);
+  __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+  __pyx_t_20 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_265MOM, 0, __pyx_mstate_global->__pyx_n_u_MOM, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[134])); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 4108, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_20);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_20, __pyx_t_16);
+  __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_MOM, __pyx_t_20) < (0)) __PYX_ERR(4, 4108, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+
+  __pyx_t_20 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_267MULT, 0, __pyx_mstate_global->__pyx_n_u_MULT, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[135])); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 4139, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_20);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_MULT, __pyx_t_20) < (0)) __PYX_ERR(4, 4139, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+
+  __pyx_t_20 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 4172, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_20);
+
+  __pyx_t_16 = PyTuple_Pack(1, __pyx_t_20); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 4170, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_16);
+  __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+  __pyx_t_20 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_269NATR, 0, __pyx_mstate_global->__pyx_n_u_NATR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[136])); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 4170, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_20);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_20, __pyx_t_16);
+  __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_NATR, __pyx_t_20) < (0)) __PYX_ERR(4, 4170, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+
+  __pyx_t_20 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_271OBV, 0, __pyx_mstate_global->__pyx_n_u_OBV, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[137])); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 4203, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_20);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_OBV, __pyx_t_20) < (0)) __PYX_ERR(4, 4203, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+
+  __pyx_t_20 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 4236, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_20);
+
+  __pyx_t_16 = PyTuple_Pack(1, __pyx_t_20); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 4234, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_16);
+  __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+  __pyx_t_20 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_273PLUS_DI, 0, __pyx_mstate_global->__pyx_n_u_PLUS_DI, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[138])); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 4234, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_20);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_20, __pyx_t_16);
+  __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_PLUS_DI, __pyx_t_20) < (0)) __PYX_ERR(4, 4234, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+
+  __pyx_t_20 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 4269, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_20);
+
+  __pyx_t_16 = PyTuple_Pack(1, __pyx_t_20); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 4267, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_16);
+  __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+  __pyx_t_20 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_275PLUS_DM, 0, __pyx_mstate_global->__pyx_n_u_PLUS_DM, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[139])); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 4267, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_20);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_20, __pyx_t_16);
+  __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_PLUS_DM, __pyx_t_20) < (0)) __PYX_ERR(4, 4267, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+
+  __pyx_t_20 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 4301, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_20);
+  __pyx_t_16 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 4301, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_16);
+  __pyx_t_3 = __Pyx_PyLong_From_int(((int)0)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 4301, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+
+  __pyx_t_19 = PyTuple_Pack(3, __pyx_t_20, __pyx_t_16, __pyx_t_3); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 4299, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_19);
+  __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+  __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_277PPO, 0, __pyx_mstate_global->__pyx_n_u_PPO, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[140])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 4299, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_19);
+  __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_PPO, __pyx_t_3) < (0)) __PYX_ERR(4, 4299, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  __pyx_t_3 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 4334, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+
+  __pyx_t_19 = PyTuple_Pack(1, __pyx_t_3); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 4332, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_19);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_279ROC, 0, __pyx_mstate_global->__pyx_n_u_ROC, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[141])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 4332, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_19);
+  __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ROC, __pyx_t_3) < (0)) __PYX_ERR(4, 4332, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  __pyx_t_3 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 4365, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+
+  __pyx_t_19 = PyTuple_Pack(1, __pyx_t_3); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 4363, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_19);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_281ROCP, 0, __pyx_mstate_global->__pyx_n_u_ROCP, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[142])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 4363, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_19);
+  __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ROCP, __pyx_t_3) < (0)) __PYX_ERR(4, 4363, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  __pyx_t_3 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 4396, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+
+  __pyx_t_19 = PyTuple_Pack(1, __pyx_t_3); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 4394, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_19);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_283ROCR, 0, __pyx_mstate_global->__pyx_n_u_ROCR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[143])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 4394, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_19);
+  __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ROCR, __pyx_t_3) < (0)) __PYX_ERR(4, 4394, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  __pyx_t_3 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 4427, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+
+  __pyx_t_19 = PyTuple_Pack(1, __pyx_t_3); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 4425, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_19);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_285ROCR100, 0, __pyx_mstate_global->__pyx_n_u_ROCR100, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[144])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 4425, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_19);
+  __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ROCR100, __pyx_t_3) < (0)) __PYX_ERR(4, 4425, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  __pyx_t_3 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 4458, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+
+  __pyx_t_19 = PyTuple_Pack(1, __pyx_t_3); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 4456, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_19);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_287RSI, 0, __pyx_mstate_global->__pyx_n_u_RSI, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[145])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 4456, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_19);
+  __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_RSI, __pyx_t_3) < (0)) __PYX_ERR(4, 4456, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  __pyx_t_3 = PyFloat_FromDouble(((double)0.02)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 4489, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_19 = PyFloat_FromDouble(((double)0.2)); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 4489, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_19);
+
+  __pyx_t_16 = PyTuple_Pack(2, __pyx_t_3, __pyx_t_19); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 4487, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_16);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
+  __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_289SAR, 0, __pyx_mstate_global->__pyx_n_u_SAR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[146])); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 4487, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_19);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_19, __pyx_t_16);
+  __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_SAR, __pyx_t_19) < (0)) __PYX_ERR(4, 4487, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
+
+  __pyx_t_19 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 4522, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_19);
+  __pyx_t_16 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 4522, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_16);
+  __pyx_t_3 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 4522, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_20 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 4522, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_20);
+  __pyx_t_4 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 4522, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_15 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_15)) __PYX_ERR(4, 4522, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_15);
+  __pyx_t_2 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 4522, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_7 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 4522, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+
+  __pyx_t_6 = PyTuple_Pack(8, __pyx_t_19, __pyx_t_16, __pyx_t_3, __pyx_t_20, __pyx_t_4, __pyx_t_15, __pyx_t_2, __pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 4520, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
+  __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_291SAREXT, 0, __pyx_mstate_global->__pyx_n_u_SAREXT, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[147])); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 4520, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_7, __pyx_t_6);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_SAREXT, __pyx_t_7) < (0)) __PYX_ERR(4, 4520, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_293SIN, 0, __pyx_mstate_global->__pyx_n_u_SIN, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[148])); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 4559, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_SIN, __pyx_t_7) < (0)) __PYX_ERR(4, 4559, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_295SINH, 0, __pyx_mstate_global->__pyx_n_u_SINH, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[149])); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 4588, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_SINH, __pyx_t_7) < (0)) __PYX_ERR(4, 4588, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 4619, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+
+  __pyx_t_6 = PyTuple_Pack(1, __pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 4617, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_297SMA, 0, __pyx_mstate_global->__pyx_n_u_SMA, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[150])); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 4617, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_7, __pyx_t_6);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_SMA, __pyx_t_7) < (0)) __PYX_ERR(4, 4617, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_299SQRT, 0, __pyx_mstate_global->__pyx_n_u_SQRT, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[151])); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 4648, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_SQRT, __pyx_t_7) < (0)) __PYX_ERR(4, 4648, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 4679, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __pyx_t_6 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 4679, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+
+  __pyx_t_2 = PyTuple_Pack(2, __pyx_t_7, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 4677, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_301STDDEV, 0, __pyx_mstate_global->__pyx_n_u_STDDEV, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[152])); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 4677, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_6, __pyx_t_2);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_STDDEV, __pyx_t_6) < (0)) __PYX_ERR(4, 4677, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+
+  __pyx_t_6 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 4711, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __pyx_t_2 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 4711, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_7 = __Pyx_PyLong_From_int(((int)0)); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 4711, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __pyx_t_15 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_15)) __PYX_ERR(4, 4711, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_15);
+  __pyx_t_4 = __Pyx_PyLong_From_int(((int)0)); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 4711, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+
+  __pyx_t_20 = PyTuple_Pack(5, __pyx_t_6, __pyx_t_2, __pyx_t_7, __pyx_t_15, __pyx_t_4); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 4709, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_20);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_303STOCH, 0, __pyx_mstate_global->__pyx_n_u_STOCH, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[153])); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 4709, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_4, __pyx_t_20);
+  __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_STOCH, __pyx_t_4) < (0)) __PYX_ERR(4, 4709, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+  __pyx_t_4 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 4751, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_20 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 4751, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_20);
+  __pyx_t_15 = __Pyx_PyLong_From_int(((int)0)); if (unlikely(!__pyx_t_15)) __PYX_ERR(4, 4751, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_15);
+
+  __pyx_t_7 = PyTuple_Pack(3, __pyx_t_4, __pyx_t_20, __pyx_t_15); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 4749, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
+  __pyx_t_15 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_305STOCHF, 0, __pyx_mstate_global->__pyx_n_u_STOCHF, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[154])); if (unlikely(!__pyx_t_15)) __PYX_ERR(4, 4749, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_15);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_15, __pyx_t_7);
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_STOCHF, __pyx_t_15) < (0)) __PYX_ERR(4, 4749, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
+
+  __pyx_t_15 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_15)) __PYX_ERR(4, 4789, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_15);
+  __pyx_t_7 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 4789, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __pyx_t_20 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 4789, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_20);
+  __pyx_t_4 = __Pyx_PyLong_From_int(((int)0)); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 4789, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+
+  __pyx_t_2 = PyTuple_Pack(4, __pyx_t_15, __pyx_t_7, __pyx_t_20, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 4787, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_307STOCHRSI, 0, __pyx_mstate_global->__pyx_n_u_STOCHRSI, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[155])); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 4787, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_4, __pyx_t_2);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_STOCHRSI, __pyx_t_4) < (0)) __PYX_ERR(4, 4787, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_309SUB, 0, __pyx_mstate_global->__pyx_n_u_SUB, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[156])); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 4824, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_SUB, __pyx_t_4) < (0)) __PYX_ERR(4, 4824, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+  __pyx_t_4 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 4857, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+
+  __pyx_t_2 = PyTuple_Pack(1, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 4855, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_311SUM, 0, __pyx_mstate_global->__pyx_n_u_SUM, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[157])); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 4855, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_4, __pyx_t_2);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_SUM, __pyx_t_4) < (0)) __PYX_ERR(4, 4855, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+  __pyx_t_4 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 4888, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_2 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 4888, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+
+  __pyx_t_20 = PyTuple_Pack(2, __pyx_t_4, __pyx_t_2); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 4886, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_20);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_313T3, 0, __pyx_mstate_global->__pyx_n_u_T3, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[158])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 4886, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_20);
+  __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_T3, __pyx_t_2) < (0)) __PYX_ERR(4, 4886, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_315TAN, 0, __pyx_mstate_global->__pyx_n_u_TAN, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[159])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 4918, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_TAN, __pyx_t_2) < (0)) __PYX_ERR(4, 4918, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_317TANH, 0, __pyx_mstate_global->__pyx_n_u_TANH, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[160])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 4947, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_TANH, __pyx_t_2) < (0)) __PYX_ERR(4, 4947, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  __pyx_t_2 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 4978, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+
+  __pyx_t_20 = PyTuple_Pack(1, __pyx_t_2); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 4976, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_20);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_319TEMA, 0, __pyx_mstate_global->__pyx_n_u_TEMA, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[161])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 4976, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_20);
+  __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_TEMA, __pyx_t_2) < (0)) __PYX_ERR(4, 4976, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_321TRANGE, 0, __pyx_mstate_global->__pyx_n_u_TRANGE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[162])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 5007, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_TRANGE, __pyx_t_2) < (0)) __PYX_ERR(4, 5007, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  __pyx_t_2 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 5040, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+
+  __pyx_t_20 = PyTuple_Pack(1, __pyx_t_2); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 5038, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_20);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_323TRIMA, 0, __pyx_mstate_global->__pyx_n_u_TRIMA, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[163])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 5038, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_20);
+  __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_TRIMA, __pyx_t_2) < (0)) __PYX_ERR(4, 5038, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  __pyx_t_2 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 5071, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+
+  __pyx_t_20 = PyTuple_Pack(1, __pyx_t_2); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 5069, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_20);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_325TRIX, 0, __pyx_mstate_global->__pyx_n_u_TRIX, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[164])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 5069, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_20);
+  __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_TRIX, __pyx_t_2) < (0)) __PYX_ERR(4, 5069, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  __pyx_t_2 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 5102, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+
+  __pyx_t_20 = PyTuple_Pack(1, __pyx_t_2); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 5100, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_20);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_327TSF, 0, __pyx_mstate_global->__pyx_n_u_TSF, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[165])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 5100, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_20);
+  __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_TSF, __pyx_t_2) < (0)) __PYX_ERR(4, 5100, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_329TYPPRICE, 0, __pyx_mstate_global->__pyx_n_u_TYPPRICE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[166])); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 5131, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_TYPPRICE, __pyx_t_2) < (0)) __PYX_ERR(4, 5131, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  __pyx_t_2 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 5164, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_20 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 5164, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_20);
+  __pyx_t_4 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 5164, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+
+  __pyx_t_7 = PyTuple_Pack(3, __pyx_t_2, __pyx_t_20, __pyx_t_4); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 5162, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_331ULTOSC, 0, __pyx_mstate_global->__pyx_n_u_ULTOSC, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[167])); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 5162, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_4, __pyx_t_7);
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ULTOSC, __pyx_t_4) < (0)) __PYX_ERR(4, 5162, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+  __pyx_t_4 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 5199, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_7 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 5199, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+
+  __pyx_t_20 = PyTuple_Pack(2, __pyx_t_4, __pyx_t_7); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 5197, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_20);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_333VAR, 0, __pyx_mstate_global->__pyx_n_u_VAR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[168])); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 5197, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_7, __pyx_t_20);
+  __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_VAR, __pyx_t_7) < (0)) __PYX_ERR(4, 5197, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_335WCLPRICE, 0, __pyx_mstate_global->__pyx_n_u_WCLPRICE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[169])); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 5229, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_WCLPRICE, __pyx_t_7) < (0)) __PYX_ERR(4, 5229, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 5262, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+
+  __pyx_t_20 = PyTuple_Pack(1, __pyx_t_7); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 5260, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_20);
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_337WILLR, 0, __pyx_mstate_global->__pyx_n_u_WILLR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[170])); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 5260, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_7, __pyx_t_20);
+  __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_WILLR, __pyx_t_7) < (0)) __PYX_ERR(4, 5260, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 5295, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+
+  __pyx_t_20 = PyTuple_Pack(1, __pyx_t_7); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 5293, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_20);
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_339WMA, 0, __pyx_mstate_global->__pyx_n_u_WMA, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[171])); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 5293, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_7, __pyx_t_20);
+  __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_WMA, __pyx_t_7) < (0)) __PYX_ERR(4, 5293, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_PyList_Pack(161, __pyx_mstate_global->__pyx_n_u_ACCBANDS, __pyx_mstate_global->__pyx_n_u_ACOS, __pyx_mstate_global->__pyx_n_u_AD, __pyx_mstate_global->__pyx_n_u_ADD, __pyx_mstate_global->__pyx_n_u_ADOSC, __pyx_mstate_global->__pyx_n_u_ADX, __pyx_mstate_global->__pyx_n_u_ADXR, __pyx_mstate_global->__pyx_n_u_APO, __pyx_mstate_global->__pyx_n_u_AROON, __pyx_mstate_global->__pyx_n_u_AROONOSC, __pyx_mstate_global->__pyx_n_u_ASIN, __pyx_mstate_global->__pyx_n_u_ATAN, __pyx_mstate_global->__pyx_n_u_ATR, __pyx_mstate_global->__pyx_n_u_AVGPRICE, __pyx_mstate_global->__pyx_n_u_AVGDEV, __pyx_mstate_global->__pyx_n_u_BBANDS, __pyx_mstate_global->__pyx_n_u_BETA, __pyx_mstate_global->__pyx_n_u_BOP, __pyx_mstate_global->__pyx_n_u_CCI, __pyx_mstate_global->__pyx_n_u_CDL2CROWS, __pyx_mstate_global->__pyx_n_u_CDL3BLACKCROWS, __pyx_mstate_global->__pyx_n_u_CDL3INSIDE, __pyx_mstate_global->__pyx_n_u_CDL3LINESTRIKE, __pyx_mstate_global->__pyx_n_u_CDL3OUTSIDE, __pyx_mstate_global->__pyx_n_u_CDL3STARSINSOUTH, __pyx_mstate_global->__pyx_n_u_CDL3WHITESOLDIERS, __pyx_mstate_global->__pyx_n_u_CDLABANDONEDBABY, __pyx_mstate_global->__pyx_n_u_CDLADVANCEBLOCK, __pyx_mstate_global->__pyx_n_u_CDLBELTHOLD, __pyx_mstate_global->__pyx_n_u_CDLBREAKAWAY, __pyx_mstate_global->__pyx_n_u_CDLCLOSINGMARUBOZU, __pyx_mstate_global->__pyx_n_u_CDLCONCEALBABYSWALL, __pyx_mstate_global->__pyx_n_u_CDLCOUNTERATTACK, __pyx_mstate_global->__pyx_n_u_CDLDARKCLOUDCOVER, __pyx_mstate_global->__pyx_n_u_CDLDOJI, __pyx_mstate_global->__pyx_n_u_CDLDOJISTAR, __pyx_mstate_global->__pyx_n_u_CDLDRAGONFLYDOJI, __pyx_mstate_global->__pyx_n_u_CDLENGULFING, __pyx_mstate_global->__pyx_n_u_CDLEVENINGDOJISTAR, __pyx_mstate_global->__pyx_n_u_CDLEVENINGSTAR, __pyx_mstate_global->__pyx_n_u_CDLGAPSIDESIDEWHITE, __pyx_mstate_global->__pyx_n_u_CDLGRAVESTONEDOJI, __pyx_mstate_global->__pyx_n_u_CDLHAMMER, __pyx_mstate_global->__pyx_n_u_CDLHANGINGMAN, __pyx_mstate_global->__pyx_n_u_CDLHARAMI, __pyx_mstate_global->__pyx_n_u_CDLHARAMICROSS, __pyx_mstate_global->__pyx_n_u_CDLHIGHWAVE, __pyx_mstate_global->__pyx_n_u_CDLHIKKAKE, __pyx_mstate_global->__pyx_n_u_CDLHIKKAKEMOD, __pyx_mstate_global->__pyx_n_u_CDLHOMINGPIGEON, __pyx_mstate_global->__pyx_n_u_CDLIDENTICAL3CROWS, __pyx_mstate_global->__pyx_n_u_CDLINNECK, __pyx_mstate_global->__pyx_n_u_CDLINVERTEDHAMMER, __pyx_mstate_global->__pyx_n_u_CDLKICKING, __pyx_mstate_global->__pyx_n_u_CDLKICKINGBYLENGTH, __pyx_mstate_global->__pyx_n_u_CDLLADDERBOTTOM, __pyx_mstate_global->__pyx_n_u_CDLLONGLEGGEDDOJI, __pyx_mstate_global->__pyx_n_u_CDLLONGLINE, __pyx_mstate_global->__pyx_n_u_CDLMARUBOZU, __pyx_mstate_global->__pyx_n_u_CDLMATCHINGLOW, __pyx_mstate_global->__pyx_n_u_CDLMATHOLD, __pyx_mstate_global->__pyx_n_u_CDLMORNINGDOJISTAR, __pyx_mstate_global->__pyx_n_u_CDLMORNINGSTAR, __pyx_mstate_global->__pyx_n_u_CDLONNECK, __pyx_mstate_global->__pyx_n_u_CDLPIERCING, __pyx_mstate_global->__pyx_n_u_CDLRICKSHAWMAN, __pyx_mstate_global->__pyx_n_u_CDLRISEFALL3METHODS, __pyx_mstate_global->__pyx_n_u_CDLSEPARATINGLINES, __pyx_mstate_global->__pyx_n_u_CDLSHOOTINGSTAR, __pyx_mstate_global->__pyx_n_u_CDLSHORTLINE, __pyx_mstate_global->__pyx_n_u_CDLSPINNINGTOP, __pyx_mstate_global->__pyx_n_u_CDLSTALLEDPATTERN, __pyx_mstate_global->__pyx_n_u_CDLSTICKSANDWICH, __pyx_mstate_global->__pyx_n_u_CDLTAKURI, __pyx_mstate_global->__pyx_n_u_CDLTASUKIGAP, __pyx_mstate_global->__pyx_n_u_CDLTHRUSTING, __pyx_mstate_global->__pyx_n_u_CDLTRISTAR, __pyx_mstate_global->__pyx_n_u_CDLUNIQUE3RIVER, __pyx_mstate_global->__pyx_n_u_CDLUPSIDEGAP2CROWS, __pyx_mstate_global->__pyx_n_u_CDLXSIDEGAP3METHODS, __pyx_mstate_global->__pyx_n_u_CEIL, __pyx_mstate_global->__pyx_n_u_CMO, __pyx_mstate_global->__pyx_n_u_CORREL, __pyx_mstate_global->__pyx_n_u_COS, __pyx_mstate_global->__pyx_n_u_COSH, __pyx_mstate_global->__pyx_n_u_DEMA, __pyx_mstate_global->__pyx_n_u_DIV, __pyx_mstate_global->__pyx_n_u_DX, __pyx_mstate_global->__pyx_n_u_EMA, __pyx_mstate_global->__pyx_n_u_EXP, __pyx_mstate_global->__pyx_n_u_FLOOR, __pyx_mstate_global->__pyx_n_u_HT_DCPERIOD, __pyx_mstate_global->__pyx_n_u_HT_DCPHASE, __pyx_mstate_global->__pyx_n_u_HT_PHASOR, __pyx_mstate_global->__pyx_n_u_HT_SINE, __pyx_mstate_global->__pyx_n_u_HT_TRENDLINE, __pyx_mstate_global->__pyx_n_u_HT_TRENDMODE, __pyx_mstate_global->__pyx_n_u_IMI, __pyx_mstate_global->__pyx_n_u_KAMA, __pyx_mstate_global->__pyx_n_u_LINEARREG, __pyx_mstate_global->__pyx_n_u_LINEARREG_ANGLE, __pyx_mstate_global->__pyx_n_u_LINEARREG_INTERCEPT, __pyx_mstate_global->__pyx_n_u_LINEARREG_SLOPE, __pyx_mstate_global->__pyx_n_u_LN, __pyx_mstate_global->__pyx_n_u_LOG10, __pyx_mstate_global->__pyx_n_u_MA, __pyx_mstate_global->__pyx_n_u_MACD, __pyx_mstate_global->__pyx_n_u_MACDEXT, __pyx_mstate_global->__pyx_n_u_MACDFIX, __pyx_mstate_global->__pyx_n_u_MAMA, __pyx_mstate_global->__pyx_n_u_MAVP, __pyx_mstate_global->__pyx_n_u_MAX, __pyx_mstate_global->__pyx_n_u_MAXINDEX, __pyx_mstate_global->__pyx_n_u_MEDPRICE, __pyx_mstate_global->__pyx_n_u_MFI, __pyx_mstate_global->__pyx_n_u_MIDPOINT, __pyx_mstate_global->__pyx_n_u_MIDPRICE, __pyx_mstate_global->__pyx_n_u_MIN, __pyx_mstate_global->__pyx_n_u_MININDEX, __pyx_mstate_global->__pyx_n_u_MINMAX, __pyx_mstate_global->__pyx_n_u_MINMAXINDEX, __pyx_mstate_global->__pyx_n_u_MINUS_DI, __pyx_mstate_global->__pyx_n_u_MINUS_DM, __pyx_mstate_global->__pyx_n_u_MOM, __pyx_mstate_global->__pyx_n_u_MULT, __pyx_mstate_global->__pyx_n_u_NATR, __pyx_mstate_global->__pyx_n_u_OBV, __pyx_mstate_global->__pyx_n_u_PLUS_DI, __pyx_mstate_global->__pyx_n_u_PLUS_DM, __pyx_mstate_global->__pyx_n_u_PPO, __pyx_mstate_global->__pyx_n_u_ROC, __pyx_mstate_global->__pyx_n_u_ROCP, __pyx_mstate_global->__pyx_n_u_ROCR, __pyx_mstate_global->__pyx_n_u_ROCR100, __pyx_mstate_global->__pyx_n_u_RSI, __pyx_mstate_global->__pyx_n_u_SAR, __pyx_mstate_global->__pyx_n_u_SAREXT, __pyx_mstate_global->__pyx_n_u_SIN, __pyx_mstate_global->__pyx_n_u_SINH, __pyx_mstate_global->__pyx_n_u_SMA, __pyx_mstate_global->__pyx_n_u_SQRT, __pyx_mstate_global->__pyx_n_u_STDDEV, __pyx_mstate_global->__pyx_n_u_STOCH, __pyx_mstate_global->__pyx_n_u_STOCHF, __pyx_mstate_global->__pyx_n_u_STOCHRSI, __pyx_mstate_global->__pyx_n_u_SUB, __pyx_mstate_global->__pyx_n_u_SUM, __pyx_mstate_global->__pyx_n_u_T3, __pyx_mstate_global->__pyx_n_u_TAN, __pyx_mstate_global->__pyx_n_u_TANH, __pyx_mstate_global->__pyx_n_u_TEMA, __pyx_mstate_global->__pyx_n_u_TRANGE, __pyx_mstate_global->__pyx_n_u_TRIMA, __pyx_mstate_global->__pyx_n_u_TRIX, __pyx_mstate_global->__pyx_n_u_TSF, __pyx_mstate_global->__pyx_n_u_TYPPRICE, __pyx_mstate_global->__pyx_n_u_ULTOSC, __pyx_mstate_global->__pyx_n_u_VAR, __pyx_mstate_global->__pyx_n_u_WCLPRICE, __pyx_mstate_global->__pyx_n_u_WILLR, __pyx_mstate_global->__pyx_n_u_WMA); if (unlikely(!__pyx_t_7)) __PYX_ERR(4, 5324, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_TA_FUNCTION_NAMES, __pyx_t_7) < (0)) __PYX_ERR(4, 5324, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_ImportDottedModuleRelFirst(__pyx_mstate_global->__pyx_n_u_math, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 4, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_math, __pyx_t_7) < (0)) __PYX_ERR(2, 4, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_ImportDottedModuleRelFirst(__pyx_mstate_global->__pyx_n_u_threading, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 5, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_threading, __pyx_t_7) < (0)) __PYX_ERR(2, 5, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_24, &__pyx_t_25);
+    __Pyx_XGOTREF(__pyx_t_1);
+    __Pyx_XGOTREF(__pyx_t_24);
+    __Pyx_XGOTREF(__pyx_t_25);
+    /*try:*/ {
+
+      __pyx_t_7 = __Pyx_PyList_Pack(1, __pyx_mstate_global->__pyx_n_u_OrderedDict); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 7, __pyx_L11_error)
+      __Pyx_GOTREF(__pyx_t_7);
+      __pyx_t_20 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_collections, __pyx_t_7, -1); if (unlikely(!__pyx_t_20)) __PYX_ERR(2, 7, __pyx_L11_error)
+      __Pyx_GOTREF(__pyx_t_20);
+      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+      __pyx_t_7 = __Pyx_ImportFrom(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_OrderedDict); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 7, __pyx_L11_error)
+      __Pyx_GOTREF(__pyx_t_7);
+      if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_OrderedDict, __pyx_t_7) < (0)) __PYX_ERR(2, 7, __pyx_L11_error)
+      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+      __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+
+    }
+    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_XDECREF(__pyx_t_24); __pyx_t_24 = 0;
+    __Pyx_XDECREF(__pyx_t_25); __pyx_t_25 = 0;
+    goto __pyx_L16_try_end;
+    __pyx_L11_error:;
+    __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+    __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
+    __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
+    __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
+    __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0;
+    __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0;
+    __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0;
+    __Pyx_XDECREF(__pyx_t_19); __pyx_t_19 = 0;
+    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_XDECREF(__pyx_t_20); __pyx_t_20 = 0;
+    __Pyx_XDECREF(__pyx_t_21); __pyx_t_21 = 0;
+    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+    __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+
+    __pyx_t_23 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_ImportError);
+    if (__pyx_t_23) {
+      __Pyx_AddTraceback("talib._ta_lib", __pyx_clineno, __pyx_lineno, __pyx_filename);
+      if (__Pyx_GetException(&__pyx_t_20, &__pyx_t_7, &__pyx_t_4) < 0) __PYX_ERR(2, 8, __pyx_L13_except_error)
+      __Pyx_XGOTREF(__pyx_t_20);
+      __Pyx_XGOTREF(__pyx_t_7);
+      __Pyx_XGOTREF(__pyx_t_4);
+
+      __pyx_t_2 = __Pyx_PyList_Pack(1, __pyx_mstate_global->__pyx_n_u_OrderedDict); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 9, __pyx_L13_except_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __pyx_t_15 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_ordereddict, __pyx_t_2, -1); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 9, __pyx_L13_except_error)
+      __Pyx_GOTREF(__pyx_t_15);
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_15, __pyx_mstate_global->__pyx_n_u_OrderedDict); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 9, __pyx_L13_except_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_OrderedDict, __pyx_t_2) < (0)) __PYX_ERR(2, 9, __pyx_L13_except_error)
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
+      __Pyx_XDECREF(__pyx_t_20); __pyx_t_20 = 0;
+      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      goto __pyx_L12_exception_handled;
+    }
+    goto __pyx_L13_except_error;
+
+    __pyx_L13_except_error:;
+    __Pyx_XGIVEREF(__pyx_t_1);
+    __Pyx_XGIVEREF(__pyx_t_24);
+    __Pyx_XGIVEREF(__pyx_t_25);
+    __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_24, __pyx_t_25);
+    goto __pyx_L1_error;
+    __pyx_L12_exception_handled:;
+    __Pyx_XGIVEREF(__pyx_t_1);
+    __Pyx_XGIVEREF(__pyx_t_24);
+    __Pyx_XGIVEREF(__pyx_t_25);
+    __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_24, __pyx_t_25);
+    __pyx_L16_try_end:;
+  }
+
+  __pyx_t_4 = __Pyx_ImportDottedModuleRelFirst(__pyx_mstate_global->__pyx_n_u_numpy, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 11, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_numpy, __pyx_t_4) < (0)) __PYX_ERR(2, 11, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+  __pyx_t_4 = __Pyx_ImportDottedModuleRelFirst(__pyx_mstate_global->__pyx_n_u_sys, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 12, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_sys, __pyx_t_4) < (0)) __PYX_ERR(2, 12, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+  __pyx_t_23 = __pyx_f_5numpy_import_array(); if (unlikely(__pyx_t_23 == ((int)-1))) __PYX_ERR(2, 18, __pyx_L1_error)
+
+  __pyx_t_4 = __Pyx_PyDict_NewPresized(4); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 21, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_price, __pyx_mstate_global->__pyx_n_u_close) < (0)) __PYX_ERR(2, 21, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_price0, __pyx_mstate_global->__pyx_n_u_high) < (0)) __PYX_ERR(2, 21, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_price1, __pyx_mstate_global->__pyx_n_u_low) < (0)) __PYX_ERR(2, 21, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_periods, __pyx_mstate_global->__pyx_n_u_periods) < (0)) __PYX_ERR(2, 21, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_INPUT_PRICE_SERIES_DEFAULTS, __pyx_t_4) < (0)) __PYX_ERR(2, 21, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+  __pyx_t_4 = __Pyx_PyList_Pack(1, ((PyObject *)(&PyDict_Type))); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 27, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_INPUT_ARRAYS_TYPES, __pyx_t_4) < (0)) __PYX_ERR(2, 27, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+  __pyx_t_4 = __Pyx_PyList_Pack(1, ((PyObject *)__pyx_mstate_global->__pyx_ptype_5numpy_ndarray)); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 28, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ARRAY_TYPES, __pyx_t_4) < (0)) __PYX_ERR(2, 28, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+  {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ExceptionSave(&__pyx_t_25, &__pyx_t_24, &__pyx_t_1);
+    __Pyx_XGOTREF(__pyx_t_25);
+    __Pyx_XGOTREF(__pyx_t_24);
+    __Pyx_XGOTREF(__pyx_t_1);
+    /*try:*/ {
+
+      __pyx_t_4 = __Pyx_ImportDottedModuleRelFirst(__pyx_mstate_global->__pyx_n_u_pandas, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 32, __pyx_L19_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_pandas, __pyx_t_4) < (0)) __PYX_ERR(2, 32, __pyx_L19_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+      __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_INPUT_ARRAYS_TYPES); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 33, __pyx_L19_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_pandas); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 33, __pyx_L19_error)
+      __Pyx_GOTREF(__pyx_t_7);
+      __pyx_t_20 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_DataFrame); if (unlikely(!__pyx_t_20)) __PYX_ERR(2, 33, __pyx_L19_error)
+      __Pyx_GOTREF(__pyx_t_20);
+      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+      __pyx_t_26 = __Pyx_PyObject_Append(__pyx_t_4, __pyx_t_20); if (unlikely(__pyx_t_26 == ((int)-1))) __PYX_ERR(2, 33, __pyx_L19_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+
+      __Pyx_GetModuleGlobalName(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_ARRAY_TYPES); if (unlikely(!__pyx_t_20)) __PYX_ERR(2, 34, __pyx_L19_error)
+      __Pyx_GOTREF(__pyx_t_20);
+      __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_pandas); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 34, __pyx_L19_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_Series); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 34, __pyx_L19_error)
+      __Pyx_GOTREF(__pyx_t_7);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __pyx_t_26 = __Pyx_PyObject_Append(__pyx_t_20, __pyx_t_7); if (unlikely(__pyx_t_26 == ((int)-1))) __PYX_ERR(2, 34, __pyx_L19_error)
+      __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+      __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_pandas); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 35, __pyx_L19_error)
+      __Pyx_GOTREF(__pyx_t_7);
+      __pyx_t_20 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_DataFrame); if (unlikely(!__pyx_t_20)) __PYX_ERR(2, 35, __pyx_L19_error)
+      __Pyx_GOTREF(__pyx_t_20);
+      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+      if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_PANDAS_DATAFRAME, __pyx_t_20) < (0)) __PYX_ERR(2, 35, __pyx_L19_error)
+      __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+
+      __Pyx_GetModuleGlobalName(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_pandas); if (unlikely(!__pyx_t_20)) __PYX_ERR(2, 36, __pyx_L19_error)
+      __Pyx_GOTREF(__pyx_t_20);
+      __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_Series); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 36, __pyx_L19_error)
+      __Pyx_GOTREF(__pyx_t_7);
+      __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+      if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_PANDAS_SERIES, __pyx_t_7) < (0)) __PYX_ERR(2, 36, __pyx_L19_error)
+      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+    }
+    __Pyx_XDECREF(__pyx_t_25); __pyx_t_25 = 0;
+    __Pyx_XDECREF(__pyx_t_24); __pyx_t_24 = 0;
+    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+    goto __pyx_L24_try_end;
+    __pyx_L19_error:;
+    __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+    __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
+    __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
+    __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
+    __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0;
+    __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0;
+    __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0;
+    __Pyx_XDECREF(__pyx_t_19); __pyx_t_19 = 0;
+    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_XDECREF(__pyx_t_20); __pyx_t_20 = 0;
+    __Pyx_XDECREF(__pyx_t_21); __pyx_t_21 = 0;
+    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+    __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+
+    __pyx_t_23 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_ImportError);
+    if (__pyx_t_23) {
+      __Pyx_AddTraceback("talib._ta_lib", __pyx_clineno, __pyx_lineno, __pyx_filename);
+      if (__Pyx_GetException(&__pyx_t_7, &__pyx_t_20, &__pyx_t_4) < 0) __PYX_ERR(2, 37, __pyx_L21_except_error)
+      __Pyx_XGOTREF(__pyx_t_7);
+      __Pyx_XGOTREF(__pyx_t_20);
+      __Pyx_XGOTREF(__pyx_t_4);
+      if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_import_error, __pyx_t_20) < (0)) __PYX_ERR(2, 37, __pyx_L21_except_error)
+
+      {
+        __Pyx_PyThreadState_declare
+        __Pyx_PyThreadState_assign
+        __Pyx_ExceptionSave(&__pyx_t_27, &__pyx_t_28, &__pyx_t_29);
+        __Pyx_XGOTREF(__pyx_t_27);
+        __Pyx_XGOTREF(__pyx_t_28);
+        __Pyx_XGOTREF(__pyx_t_29);
+        /*try:*/ {
+
+          __Pyx_GetModuleGlobalName(__pyx_t_15, __pyx_mstate_global->__pyx_n_u_import_error); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 39, __pyx_L27_error)
+          __Pyx_GOTREF(__pyx_t_15);
+          __pyx_t_31 = PyObject_IsInstance(__pyx_t_15, __pyx_builtin_ModuleNotFoundError); if (unlikely(__pyx_t_31 == ((int)-1))) __PYX_ERR(2, 39, __pyx_L27_error)
+          __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
+          __pyx_t_32 = (!__pyx_t_31);
+          if (!__pyx_t_32) {
+          } else {
+            __pyx_t_30 = __pyx_t_32;
+            goto __pyx_L36_bool_binop_done;
+          }
+          __Pyx_GetModuleGlobalName(__pyx_t_15, __pyx_mstate_global->__pyx_n_u_import_error); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 39, __pyx_L27_error)
+          __Pyx_GOTREF(__pyx_t_15);
+          __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_15, __pyx_mstate_global->__pyx_n_u_name); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 39, __pyx_L27_error)
+          __Pyx_GOTREF(__pyx_t_2);
+          __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
+          __pyx_t_32 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_pandas, Py_NE)); if (unlikely((__pyx_t_32 < 0))) __PYX_ERR(2, 39, __pyx_L27_error)
+          __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+          __pyx_t_30 = __pyx_t_32;
+          __pyx_L36_bool_binop_done:;
+          if (unlikely(__pyx_t_30)) {
+
+            __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_import_error); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 41, __pyx_L27_error)
+            __Pyx_GOTREF(__pyx_t_2);
+            __Pyx_Raise(__pyx_t_2, 0, 0, 0);
+            __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+            __PYX_ERR(2, 41, __pyx_L27_error)
+
+          }
+
+        }
+        __Pyx_XDECREF(__pyx_t_27); __pyx_t_27 = 0;
+        __Pyx_XDECREF(__pyx_t_28); __pyx_t_28 = 0;
+        __Pyx_XDECREF(__pyx_t_29); __pyx_t_29 = 0;
+        goto __pyx_L34_try_end;
+        __pyx_L27_error:;
+        __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+        __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
+        __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
+        __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
+        __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0;
+        __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0;
+        __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0;
+        __Pyx_XDECREF(__pyx_t_19); __pyx_t_19 = 0;
+        __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+        __Pyx_XDECREF(__pyx_t_21); __pyx_t_21 = 0;
+        __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+        __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+        __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+        __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+
+        __pyx_t_23 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_NameError);
+        if (__pyx_t_23) {
+          __Pyx_ErrRestore(0,0,0);
+          goto __pyx_L28_exception_handled;
+        }
+        goto __pyx_L29_except_error;
+
+        __pyx_L29_except_error:;
+        __Pyx_XGIVEREF(__pyx_t_27);
+        __Pyx_XGIVEREF(__pyx_t_28);
+        __Pyx_XGIVEREF(__pyx_t_29);
+        __Pyx_ExceptionReset(__pyx_t_27, __pyx_t_28, __pyx_t_29);
+        goto __pyx_L21_except_error;
+        __pyx_L28_exception_handled:;
+        __Pyx_XGIVEREF(__pyx_t_27);
+        __Pyx_XGIVEREF(__pyx_t_28);
+        __Pyx_XGIVEREF(__pyx_t_29);
+        __Pyx_ExceptionReset(__pyx_t_27, __pyx_t_28, __pyx_t_29);
+        __pyx_L34_try_end:;
+      }
+
+      if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_PANDAS_DATAFRAME, Py_None) < (0)) __PYX_ERR(2, 46, __pyx_L21_except_error)
+
+      if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_PANDAS_SERIES, Py_None) < (0)) __PYX_ERR(2, 47, __pyx_L21_except_error)
+      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+      __Pyx_XDECREF(__pyx_t_20); __pyx_t_20 = 0;
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      goto __pyx_L20_exception_handled;
+    }
+    goto __pyx_L21_except_error;
+
+    __pyx_L21_except_error:;
+    __Pyx_XGIVEREF(__pyx_t_25);
+    __Pyx_XGIVEREF(__pyx_t_24);
+    __Pyx_XGIVEREF(__pyx_t_1);
+    __Pyx_ExceptionReset(__pyx_t_25, __pyx_t_24, __pyx_t_1);
+    goto __pyx_L1_error;
+    __pyx_L20_exception_handled:;
+    __Pyx_XGIVEREF(__pyx_t_25);
+    __Pyx_XGIVEREF(__pyx_t_24);
+    __Pyx_XGIVEREF(__pyx_t_1);
+    __Pyx_ExceptionReset(__pyx_t_25, __pyx_t_24, __pyx_t_1);
+    __pyx_L24_try_end:;
+  }
+
+  {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_24, &__pyx_t_25);
+    __Pyx_XGOTREF(__pyx_t_1);
+    __Pyx_XGOTREF(__pyx_t_24);
+    __Pyx_XGOTREF(__pyx_t_25);
+    /*try:*/ {
+
+      __pyx_t_4 = __Pyx_ImportDottedModuleRelFirst(__pyx_mstate_global->__pyx_n_u_polars, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 51, __pyx_L40_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_polars, __pyx_t_4) < (0)) __PYX_ERR(2, 51, __pyx_L40_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+      __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_INPUT_ARRAYS_TYPES); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 52, __pyx_L40_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_GetModuleGlobalName(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_polars); if (unlikely(!__pyx_t_20)) __PYX_ERR(2, 52, __pyx_L40_error)
+      __Pyx_GOTREF(__pyx_t_20);
+      __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_DataFrame); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 52, __pyx_L40_error)
+      __Pyx_GOTREF(__pyx_t_7);
+      __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+      __pyx_t_26 = __Pyx_PyObject_Append(__pyx_t_4, __pyx_t_7); if (unlikely(__pyx_t_26 == ((int)-1))) __PYX_ERR(2, 52, __pyx_L40_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+      __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_ARRAY_TYPES); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 53, __pyx_L40_error)
+      __Pyx_GOTREF(__pyx_t_7);
+      __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_polars); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 53, __pyx_L40_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __pyx_t_20 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_Series); if (unlikely(!__pyx_t_20)) __PYX_ERR(2, 53, __pyx_L40_error)
+      __Pyx_GOTREF(__pyx_t_20);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __pyx_t_26 = __Pyx_PyObject_Append(__pyx_t_7, __pyx_t_20); if (unlikely(__pyx_t_26 == ((int)-1))) __PYX_ERR(2, 53, __pyx_L40_error)
+      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+      __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+
+      __Pyx_GetModuleGlobalName(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_polars); if (unlikely(!__pyx_t_20)) __PYX_ERR(2, 54, __pyx_L40_error)
+      __Pyx_GOTREF(__pyx_t_20);
+      __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_DataFrame); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 54, __pyx_L40_error)
+      __Pyx_GOTREF(__pyx_t_7);
+      __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+      if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_POLARS_DATAFRAME, __pyx_t_7) < (0)) __PYX_ERR(2, 54, __pyx_L40_error)
+      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+      __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_polars); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 55, __pyx_L40_error)
+      __Pyx_GOTREF(__pyx_t_7);
+      __pyx_t_20 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_Series); if (unlikely(!__pyx_t_20)) __PYX_ERR(2, 55, __pyx_L40_error)
+      __Pyx_GOTREF(__pyx_t_20);
+      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+      if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_POLARS_SERIES, __pyx_t_20) < (0)) __PYX_ERR(2, 55, __pyx_L40_error)
+      __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+
+    }
+    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_XDECREF(__pyx_t_24); __pyx_t_24 = 0;
+    __Pyx_XDECREF(__pyx_t_25); __pyx_t_25 = 0;
+    goto __pyx_L45_try_end;
+    __pyx_L40_error:;
+    __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+    __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
+    __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
+    __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
+    __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0;
+    __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0;
+    __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0;
+    __Pyx_XDECREF(__pyx_t_19); __pyx_t_19 = 0;
+    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_XDECREF(__pyx_t_20); __pyx_t_20 = 0;
+    __Pyx_XDECREF(__pyx_t_21); __pyx_t_21 = 0;
+    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+    __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+
+    __pyx_t_23 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_ImportError);
+    if (__pyx_t_23) {
+      __Pyx_AddTraceback("talib._ta_lib", __pyx_clineno, __pyx_lineno, __pyx_filename);
+      if (__Pyx_GetException(&__pyx_t_20, &__pyx_t_7, &__pyx_t_4) < 0) __PYX_ERR(2, 56, __pyx_L42_except_error)
+      __Pyx_XGOTREF(__pyx_t_20);
+      __Pyx_XGOTREF(__pyx_t_7);
+      __Pyx_XGOTREF(__pyx_t_4);
+      if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_import_error, __pyx_t_7) < (0)) __PYX_ERR(2, 56, __pyx_L42_except_error)
+
+      {
+        __Pyx_PyThreadState_declare
+        __Pyx_PyThreadState_assign
+        __Pyx_ExceptionSave(&__pyx_t_29, &__pyx_t_28, &__pyx_t_27);
+        __Pyx_XGOTREF(__pyx_t_29);
+        __Pyx_XGOTREF(__pyx_t_28);
+        __Pyx_XGOTREF(__pyx_t_27);
+        /*try:*/ {
+
+          __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_import_error); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 58, __pyx_L48_error)
+          __Pyx_GOTREF(__pyx_t_2);
+          __pyx_t_32 = PyObject_IsInstance(__pyx_t_2, __pyx_builtin_ModuleNotFoundError); if (unlikely(__pyx_t_32 == ((int)-1))) __PYX_ERR(2, 58, __pyx_L48_error)
+          __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+          __pyx_t_31 = (!__pyx_t_32);
+          if (!__pyx_t_31) {
+          } else {
+            __pyx_t_30 = __pyx_t_31;
+            goto __pyx_L57_bool_binop_done;
+          }
+          __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_import_error); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 58, __pyx_L48_error)
+          __Pyx_GOTREF(__pyx_t_2);
+          __pyx_t_15 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_name); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 58, __pyx_L48_error)
+          __Pyx_GOTREF(__pyx_t_15);
+          __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+          __pyx_t_31 = (__Pyx_PyUnicode_Equals(__pyx_t_15, __pyx_mstate_global->__pyx_n_u_polars, Py_NE)); if (unlikely((__pyx_t_31 < 0))) __PYX_ERR(2, 58, __pyx_L48_error)
+          __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
+          __pyx_t_30 = __pyx_t_31;
+          __pyx_L57_bool_binop_done:;
+          if (unlikely(__pyx_t_30)) {
+
+            __Pyx_GetModuleGlobalName(__pyx_t_15, __pyx_mstate_global->__pyx_n_u_import_error); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 60, __pyx_L48_error)
+            __Pyx_GOTREF(__pyx_t_15);
+            __Pyx_Raise(__pyx_t_15, 0, 0, 0);
+            __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
+            __PYX_ERR(2, 60, __pyx_L48_error)
+
+          }
+
+        }
+        __Pyx_XDECREF(__pyx_t_29); __pyx_t_29 = 0;
+        __Pyx_XDECREF(__pyx_t_28); __pyx_t_28 = 0;
+        __Pyx_XDECREF(__pyx_t_27); __pyx_t_27 = 0;
+        goto __pyx_L55_try_end;
+        __pyx_L48_error:;
+        __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
+        __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
+        __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
+        __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
+        __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0;
+        __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0;
+        __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0;
+        __Pyx_XDECREF(__pyx_t_19); __pyx_t_19 = 0;
+        __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+        __Pyx_XDECREF(__pyx_t_21); __pyx_t_21 = 0;
+        __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+        __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+        __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+        __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+
+        __pyx_t_23 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_NameError);
+        if (__pyx_t_23) {
+          __Pyx_ErrRestore(0,0,0);
+          goto __pyx_L49_exception_handled;
+        }
+        goto __pyx_L50_except_error;
+
+        __pyx_L50_except_error:;
+        __Pyx_XGIVEREF(__pyx_t_29);
+        __Pyx_XGIVEREF(__pyx_t_28);
+        __Pyx_XGIVEREF(__pyx_t_27);
+        __Pyx_ExceptionReset(__pyx_t_29, __pyx_t_28, __pyx_t_27);
+        goto __pyx_L42_except_error;
+        __pyx_L49_exception_handled:;
+        __Pyx_XGIVEREF(__pyx_t_29);
+        __Pyx_XGIVEREF(__pyx_t_28);
+        __Pyx_XGIVEREF(__pyx_t_27);
+        __Pyx_ExceptionReset(__pyx_t_29, __pyx_t_28, __pyx_t_27);
+        __pyx_L55_try_end:;
+      }
+
+      if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_POLARS_DATAFRAME, Py_None) < (0)) __PYX_ERR(2, 65, __pyx_L42_except_error)
+
+      if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_POLARS_SERIES, Py_None) < (0)) __PYX_ERR(2, 66, __pyx_L42_except_error)
+      __Pyx_XDECREF(__pyx_t_20); __pyx_t_20 = 0;
+      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      goto __pyx_L41_exception_handled;
+    }
+    goto __pyx_L42_except_error;
+
+    __pyx_L42_except_error:;
+    __Pyx_XGIVEREF(__pyx_t_1);
+    __Pyx_XGIVEREF(__pyx_t_24);
+    __Pyx_XGIVEREF(__pyx_t_25);
+    __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_24, __pyx_t_25);
+    goto __pyx_L1_error;
+    __pyx_L41_exception_handled:;
+    __Pyx_XGIVEREF(__pyx_t_1);
+    __Pyx_XGIVEREF(__pyx_t_24);
+    __Pyx_XGIVEREF(__pyx_t_25);
+    __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_24, __pyx_t_25);
+    __pyx_L45_try_end:;
+  }
+
+  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_INPUT_ARRAYS_TYPES); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 68, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_7 = __Pyx_PySequence_Tuple(__pyx_t_4); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 68, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_INPUT_ARRAYS_TYPES, __pyx_t_7) < (0)) __PYX_ERR(2, 68, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_ARRAY_TYPES); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 69, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __pyx_t_4 = __Pyx_PySequence_Tuple(__pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 69, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ARRAY_TYPES, __pyx_t_4) < (0)) __PYX_ERR(2, 69, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_sys); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 72, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_version); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 72, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = PyObject_RichCompare(__pyx_t_7, __pyx_mstate_global->__pyx_kp_u_3, Py_GE); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 72, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  __pyx_t_30 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_30 < 0))) __PYX_ERR(2, 72, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  if (__pyx_t_30) {
+
+    __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_341str2bytes, 0, __pyx_mstate_global->__pyx_n_u_str2bytes, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[172])); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 74, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_str2bytes, __pyx_t_4) < (0)) __PYX_ERR(2, 74, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+    __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_343bytes2str, 0, __pyx_mstate_global->__pyx_n_u_bytes2str, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[173])); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 77, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_bytes2str, __pyx_t_4) < (0)) __PYX_ERR(2, 77, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+    goto __pyx_L61;
+  }
+
+  /*else*/ {
+    __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_345str2bytes, 0, __pyx_mstate_global->__pyx_n_u_str2bytes, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[174])); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 82, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_str2bytes, __pyx_t_4) < (0)) __PYX_ERR(2, 82, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+    __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_347bytes2str, 0, __pyx_mstate_global->__pyx_n_u_bytes2str, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[175])); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 85, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_bytes2str, __pyx_t_4) < (0)) __PYX_ERR(2, 85, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  }
+  __pyx_L61:;
+
+  __pyx_t_4 = __Pyx_PEP560_update_bases(__pyx_mstate_global->__pyx_tuple[8]); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 88, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_7 = __Pyx_CalculateMetaclass(NULL, __pyx_t_4); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 88, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __pyx_t_20 = __Pyx_Py3MetaclassPrepare(__pyx_t_7, __pyx_t_4, __pyx_mstate_global->__pyx_n_u_Function, __pyx_mstate_global->__pyx_n_u_Function, (PyObject *) NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_kp_u_This_is_a_pythonic_wrapper_arou); if (unlikely(!__pyx_t_20)) __PYX_ERR(2, 88, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_20);
+  if (__pyx_t_4 != __pyx_mstate_global->__pyx_tuple[8]) {
+    if (unlikely((PyDict_SetItemString(__pyx_t_20, "__orig_bases__", __pyx_mstate_global->__pyx_tuple[8]) < 0))) __PYX_ERR(2, 88, __pyx_L1_error)
+  }
+
+  __pyx_t_15 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_1__init__, 0, __pyx_mstate_global->__pyx_n_u_Function___init, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[176])); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 117, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_15);
+  if (__Pyx_SetNameInClass(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_init, __pyx_t_15) < (0)) __PYX_ERR(2, 117, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
+
+  __pyx_t_2 = NULL;
+  __Pyx_INCREF(__pyx_builtin_property);
+  __pyx_t_6 = __pyx_builtin_property; 
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_3__local, 0, __pyx_mstate_global->__pyx_n_u_Function___local, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[177])); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 130, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_8 = 1;
+  {
+    PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_t_3};
+    __pyx_t_15 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 130, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_15);
+  }
+  if (__Pyx_SetNameInClass(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_Function__local, __pyx_t_15) < (0)) __PYX_ERR(2, 130, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
+
+  __pyx_t_6 = NULL;
+  __Pyx_INCREF(__pyx_builtin_property);
+  __pyx_t_3 = __pyx_builtin_property; 
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_5info, 0, __pyx_mstate_global->__pyx_n_u_Function_info, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[178])); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 172, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_8 = 1;
+  {
+    PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_2};
+    __pyx_t_15 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 172, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_15);
+  }
+  if (__Pyx_SetNameInClass(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_info, __pyx_t_15) < (0)) __PYX_ERR(2, 172, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
+
+  __pyx_t_3 = NULL;
+  __Pyx_INCREF(__pyx_builtin_property);
+  __pyx_t_2 = __pyx_builtin_property; 
+  __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_7function_flags, 0, __pyx_mstate_global->__pyx_n_u_Function_function_flags, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[179])); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 179, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __pyx_t_8 = 1;
+  {
+    PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_t_6};
+    __pyx_t_15 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 179, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_15);
+  }
+  if (__Pyx_SetNameInClass(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_function_flags, __pyx_t_15) < (0)) __PYX_ERR(2, 179, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
+
+  __pyx_t_2 = NULL;
+  __Pyx_INCREF(__pyx_builtin_property);
+  __pyx_t_6 = __pyx_builtin_property; 
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_9output_flags, 0, __pyx_mstate_global->__pyx_n_u_Function_output_flags, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[180])); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 186, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_8 = 1;
+  {
+    PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_t_3};
+    __pyx_t_15 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 186, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_15);
+  }
+  if (__Pyx_SetNameInClass(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_output_flags, __pyx_t_15) < (0)) __PYX_ERR(2, 186, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
+
+  __pyx_t_15 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_11get_input_names, 0, __pyx_mstate_global->__pyx_n_u_Function_get_input_names, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[181])); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 193, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_15);
+  if (__Pyx_SetNameInClass(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_get_input_names, __pyx_t_15) < (0)) __PYX_ERR(2, 193, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
+
+  __pyx_t_15 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_13set_input_names, 0, __pyx_mstate_global->__pyx_n_u_Function_set_input_names, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[182])); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 204, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_15);
+  if (__Pyx_SetNameInClass(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_set_input_names, __pyx_t_15) < (0)) __PYX_ERR(2, 204, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
+
+  __pyx_t_6 = NULL;
+  __Pyx_INCREF(__pyx_builtin_property);
+  __pyx_t_3 = __pyx_builtin_property; 
+  __pyx_t_2 = PyObject_GetItem(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_get_input_names);
+  if (unlikely(!__pyx_t_2)) {
+    PyErr_Clear();
+    __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_get_input_names);
+  }
+  if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 214, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_16 = PyObject_GetItem(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_set_input_names);
+  if (unlikely(!__pyx_t_16)) {
+    PyErr_Clear();
+    __Pyx_GetModuleGlobalName(__pyx_t_16, __pyx_mstate_global->__pyx_n_u_set_input_names);
+  }
+  if (unlikely(!__pyx_t_16)) __PYX_ERR(2, 214, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_16);
+  __pyx_t_8 = 1;
+  {
+    PyObject *__pyx_callargs[3] = {__pyx_t_6, __pyx_t_2, __pyx_t_16};
+    __pyx_t_15 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_8, (3-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 214, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_15);
+  }
+  if (__Pyx_SetNameInClass(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_input_names, __pyx_t_15) < (0)) __PYX_ERR(2, 214, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
+
+  __pyx_t_15 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_15get_input_arrays, 0, __pyx_mstate_global->__pyx_n_u_Function_get_input_arrays, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[183])); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 216, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_15);
+  if (__Pyx_SetNameInClass(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_get_input_arrays, __pyx_t_15) < (0)) __PYX_ERR(2, 216, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
+
+  __pyx_t_15 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_17set_input_arrays, 0, __pyx_mstate_global->__pyx_n_u_Function_set_input_arrays, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[184])); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 227, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_15);
+  if (__Pyx_SetNameInClass(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_set_input_arrays, __pyx_t_15) < (0)) __PYX_ERR(2, 227, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
+
+  __pyx_t_3 = NULL;
+  __Pyx_INCREF(__pyx_builtin_property);
+  __pyx_t_16 = __pyx_builtin_property; 
+  __pyx_t_2 = PyObject_GetItem(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_get_input_arrays);
+  if (unlikely(!__pyx_t_2)) {
+    PyErr_Clear();
+    __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_get_input_arrays);
+  }
+  if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 274, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_6 = PyObject_GetItem(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_set_input_arrays);
+  if (unlikely(!__pyx_t_6)) {
+    PyErr_Clear();
+    __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_set_input_arrays);
+  }
+  if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 274, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __pyx_t_8 = 1;
+  {
+    PyObject *__pyx_callargs[3] = {__pyx_t_3, __pyx_t_2, __pyx_t_6};
+    __pyx_t_15 = __Pyx_PyObject_FastCall(__pyx_t_16, __pyx_callargs+__pyx_t_8, (3-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
+    if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 274, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_15);
+  }
+  if (__Pyx_SetNameInClass(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_input_arrays, __pyx_t_15) < (0)) __PYX_ERR(2, 274, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
+
+  __pyx_t_15 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_19get_parameters, 0, __pyx_mstate_global->__pyx_n_u_Function_get_parameters, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[185])); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 276, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_15);
+  if (__Pyx_SetNameInClass(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_get_parameters, __pyx_t_15) < (0)) __PYX_ERR(2, 276, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
+
+  __pyx_t_15 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_21set_parameters, 0, __pyx_mstate_global->__pyx_n_u_Function_set_parameters, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[186])); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 286, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_15);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_15, __pyx_mstate_global->__pyx_tuple[9]);
+  if (__Pyx_SetNameInClass(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_set_parameters, __pyx_t_15) < (0)) __PYX_ERR(2, 286, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
+
+  __pyx_t_16 = NULL;
+  __Pyx_INCREF(__pyx_builtin_property);
+  __pyx_t_6 = __pyx_builtin_property; 
+  __pyx_t_2 = PyObject_GetItem(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_get_parameters);
+  if (unlikely(!__pyx_t_2)) {
+    PyErr_Clear();
+    __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_get_parameters);
+  }
+  if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 299, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = PyObject_GetItem(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_set_parameters);
+  if (unlikely(!__pyx_t_3)) {
+    PyErr_Clear();
+    __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_set_parameters);
+  }
+  if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 299, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_8 = 1;
+  {
+    PyObject *__pyx_callargs[3] = {__pyx_t_16, __pyx_t_2, __pyx_t_3};
+    __pyx_t_15 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+__pyx_t_8, (3-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+    __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0;
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 299, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_15);
+  }
+  if (__Pyx_SetNameInClass(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_parameters, __pyx_t_15) < (0)) __PYX_ERR(2, 299, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
+
+  __pyx_t_15 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_23set_function_args, 0, __pyx_mstate_global->__pyx_n_u_Function_set_function_args, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[187])); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 301, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_15);
+  if (__Pyx_SetNameInClass(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_set_function_args, __pyx_t_15) < (0)) __PYX_ERR(2, 301, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
+
+  __pyx_t_6 = NULL;
+  __Pyx_INCREF(__pyx_builtin_property);
+  __pyx_t_3 = __pyx_builtin_property; 
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_25lookback, 0, __pyx_mstate_global->__pyx_n_u_Function_lookback, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[188])); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 336, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_8 = 1;
+  {
+    PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_2};
+    __pyx_t_15 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 336, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_15);
+  }
+  if (__Pyx_SetNameInClass(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_lookback, __pyx_t_15) < (0)) __PYX_ERR(2, 336, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
+
+  __pyx_t_3 = NULL;
+  __Pyx_INCREF(__pyx_builtin_property);
+  __pyx_t_2 = __pyx_builtin_property; 
+  __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_27output_names, 0, __pyx_mstate_global->__pyx_n_u_Function_output_names, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[189])); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 357, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __pyx_t_8 = 1;
+  {
+    PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_t_6};
+    __pyx_t_15 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 357, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_15);
+  }
+  if (__Pyx_SetNameInClass(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_output_names, __pyx_t_15) < (0)) __PYX_ERR(2, 357, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
+
+  __pyx_t_2 = NULL;
+  __Pyx_INCREF(__pyx_builtin_property);
+  __pyx_t_6 = __pyx_builtin_property; 
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_29outputs, 0, __pyx_mstate_global->__pyx_n_u_Function_outputs, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[190])); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 367, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_8 = 1;
+  {
+    PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_t_3};
+    __pyx_t_15 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET));
+    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 367, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_15);
+  }
+  if (__Pyx_SetNameInClass(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_outputs, __pyx_t_15) < (0)) __PYX_ERR(2, 367, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
+
+  __pyx_t_15 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_31run, 0, __pyx_mstate_global->__pyx_n_u_Function_run, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[191])); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 399, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_15);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_15, __pyx_mstate_global->__pyx_tuple[9]);
+  if (__Pyx_SetNameInClass(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_run, __pyx_t_15) < (0)) __PYX_ERR(2, 399, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
+
+  __pyx_t_15 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_33__call__, 0, __pyx_mstate_global->__pyx_n_u_Function___call, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[192])); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 411, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_15);
+  if (__Pyx_SetNameInClass(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_call, __pyx_t_15) < (0)) __PYX_ERR(2, 411, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
+
+  __pyx_t_15 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_35__input_price_series_names, 0, __pyx_mstate_global->__pyx_n_u_Function___input_price_series_na, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[193])); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 477, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_15);
+  if (__Pyx_SetNameInClass(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_Function__input_price_series_na, __pyx_t_15) < (0)) __PYX_ERR(2, 477, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
+
+  __pyx_t_15 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_37__call_function, 0, __pyx_mstate_global->__pyx_n_u_Function___call_function, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[194])); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 489, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_15);
+  if (__Pyx_SetNameInClass(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_Function__call_function, __pyx_t_15) < (0)) __PYX_ERR(2, 489, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
+
+  __pyx_t_15 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_39__check_opt_input_value, 0, __pyx_mstate_global->__pyx_n_u_Function___check_opt_input_value, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[195])); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 520, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_15);
+  if (__Pyx_SetNameInClass(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_Function__check_opt_input_value, __pyx_t_15) < (0)) __PYX_ERR(2, 520, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
+
+  __pyx_t_15 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_41__get_opt_input_value, 0, __pyx_mstate_global->__pyx_n_u_Function___get_opt_input_value, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[196])); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 535, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_15);
+  if (__Pyx_SetNameInClass(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_Function__get_opt_input_value, __pyx_t_15) < (0)) __PYX_ERR(2, 535, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
+
+  __pyx_t_15 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_43__repr__, 0, __pyx_mstate_global->__pyx_n_u_Function___repr, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[197])); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 545, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_15);
+  if (__Pyx_SetNameInClass(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_repr, __pyx_t_15) < (0)) __PYX_ERR(2, 545, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
+
+  __pyx_t_15 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_45__unicode__, 0, __pyx_mstate_global->__pyx_n_u_Function___unicode, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[198])); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 548, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_15);
+  if (__Pyx_SetNameInClass(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_unicode, __pyx_t_15) < (0)) __PYX_ERR(2, 548, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
+
+  __pyx_t_15 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_47__str__, 0, __pyx_mstate_global->__pyx_n_u_Function___str, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[199])); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 551, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_15);
+  if (__Pyx_SetNameInClass(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_str, __pyx_t_15) < (0)) __PYX_ERR(2, 551, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
+
+  __pyx_t_15 = __Pyx_Py3ClassCreate(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_Function, __pyx_t_4, __pyx_t_20, NULL, 0, 1); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 88, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_15);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_Function, __pyx_t_15) < (0)) __PYX_ERR(2, 88, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
+  __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_349_ta_getGroupTable, 0, __pyx_mstate_global->__pyx_n_u_ta_getGroupTable, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[200])); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 565, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ta_getGroupTable, __pyx_t_4) < (0)) __PYX_ERR(2, 565, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_351_ta_getFuncTable, 0, __pyx_mstate_global->__pyx_n_u_ta_getFuncTable, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[201])); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 577, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ta_getFuncTable, __pyx_t_4) < (0)) __PYX_ERR(2, 577, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_353__get_flags, 0, __pyx_mstate_global->__pyx_n_u_get_flags, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[202])); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 589, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_get_flags, __pyx_t_4) < (0)) __PYX_ERR(2, 589, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+  __pyx_t_4 = __Pyx_PyDict_NewPresized(4); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 615, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_int_16777216, __pyx_mstate_global->__pyx_kp_u_Output_scale_same_as_input) < (0)) __PYX_ERR(2, 615, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_int_67108864, __pyx_mstate_global->__pyx_kp_u_Output_is_over_volume) < (0)) __PYX_ERR(2, 615, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_int_134217728, __pyx_mstate_global->__pyx_kp_u_Function_has_an_unstable_period) < (0)) __PYX_ERR(2, 615, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_int_268435456, __pyx_mstate_global->__pyx_kp_u_Output_is_a_candlestick) < (0)) __PYX_ERR(2, 615, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_TA_FUNC_FLAGS, __pyx_t_4) < (0)) __PYX_ERR(2, 614, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+  __pyx_t_4 = __Pyx_PyDict_NewPresized(7); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 623, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_int_1, __pyx_mstate_global->__pyx_n_u_open) < (0)) __PYX_ERR(2, 623, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_int_2, __pyx_mstate_global->__pyx_n_u_high) < (0)) __PYX_ERR(2, 623, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_int_4, __pyx_mstate_global->__pyx_n_u_low) < (0)) __PYX_ERR(2, 623, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_int_8, __pyx_mstate_global->__pyx_n_u_close) < (0)) __PYX_ERR(2, 623, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_int_16, __pyx_mstate_global->__pyx_n_u_volume) < (0)) __PYX_ERR(2, 623, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_int_32, __pyx_mstate_global->__pyx_n_u_openInterest) < (0)) __PYX_ERR(2, 623, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_int_64, __pyx_mstate_global->__pyx_n_u_timeStamp) < (0)) __PYX_ERR(2, 623, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_TA_INPUT_FLAGS, __pyx_t_4) < (0)) __PYX_ERR(2, 622, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+  __pyx_t_4 = __Pyx_PyDict_NewPresized(13); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 633, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_int_1, __pyx_mstate_global->__pyx_n_u_Line) < (0)) __PYX_ERR(2, 633, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_int_2, __pyx_mstate_global->__pyx_kp_u_Dotted_Line) < (0)) __PYX_ERR(2, 633, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_int_4, __pyx_mstate_global->__pyx_kp_u_Dashed_Line) < (0)) __PYX_ERR(2, 633, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_int_8, __pyx_mstate_global->__pyx_n_u_Dot) < (0)) __PYX_ERR(2, 633, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_int_16, __pyx_mstate_global->__pyx_n_u_Histogram) < (0)) __PYX_ERR(2, 633, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_int_32, __pyx_mstate_global->__pyx_kp_u_Pattern_Bool) < (0)) __PYX_ERR(2, 633, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_int_64, __pyx_mstate_global->__pyx_kp_u_Bull_Bear_Pattern_Bearish_0_Neut) < (0)) __PYX_ERR(2, 633, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_int_128, __pyx_mstate_global->__pyx_kp_u_Strength_Pattern_200_100_Bearish) < (0)) __PYX_ERR(2, 633, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_int_256, __pyx_mstate_global->__pyx_kp_u_Output_can_be_positive) < (0)) __PYX_ERR(2, 633, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_int_512, __pyx_mstate_global->__pyx_kp_u_Output_can_be_negative) < (0)) __PYX_ERR(2, 633, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_int_1024, __pyx_mstate_global->__pyx_kp_u_Output_can_be_zero) < (0)) __PYX_ERR(2, 633, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_int_2048, __pyx_mstate_global->__pyx_kp_u_Values_represent_an_upper_limit) < (0)) __PYX_ERR(2, 633, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_int_4096, __pyx_mstate_global->__pyx_kp_u_Values_represent_a_lower_limit) < (0)) __PYX_ERR(2, 633, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_TA_OUTPUT_FLAGS, __pyx_t_4) < (0)) __PYX_ERR(2, 632, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_355_ta_getFuncInfo, 0, __pyx_mstate_global->__pyx_n_u_ta_getFuncInfo, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[203])); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 648, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ta_getFuncInfo, __pyx_t_4) < (0)) __PYX_ERR(2, 648, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_357_ta_getInputParameterInfo, 0, __pyx_mstate_global->__pyx_n_u_ta_getInputParameterInfo, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[204])); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 667, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ta_getInputParameterInfo, __pyx_t_4) < (0)) __PYX_ERR(2, 667, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_359_ta_getOptInputParameterInfo, 0, __pyx_mstate_global->__pyx_n_u_ta_getOptInputParameterInfo, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[205])); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 688, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ta_getOptInputParameterInfo, __pyx_t_4) < (0)) __PYX_ERR(2, 688, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_361_ta_getOutputParameterInfo, 0, __pyx_mstate_global->__pyx_n_u_ta_getOutputParameterInfo, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[206])); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 710, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ta_getOutputParameterInfo, __pyx_t_4) < (0)) __PYX_ERR(2, 710, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_363_get_defaults_and_docs, 0, __pyx_mstate_global->__pyx_n_u_get_defaults_and_docs, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[207])); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 730, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_get_defaults_and_docs, __pyx_t_4) < (0)) __PYX_ERR(2, 730, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+  __pyx_t_23 = __pyx_f_5numpy_import_array(); if (unlikely(__pyx_t_23 == ((int)-1))) __PYX_ERR(5, 7, __pyx_L1_error)
+
+  __pyx_t_4 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 11, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+
+  __pyx_t_7 = PyTuple_Pack(1, __pyx_t_4); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 9, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_365stream_ACCBANDS, 0, __pyx_mstate_global->__pyx_n_u_stream_ACCBANDS, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[208])); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 9, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_4, __pyx_t_7);
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_ACCBANDS, __pyx_t_4) < (0)) __PYX_ERR(5, 9, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_367stream_ACOS, 0, __pyx_mstate_global->__pyx_n_u_stream_ACOS, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[209])); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 50, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_ACOS, __pyx_t_4) < (0)) __PYX_ERR(5, 50, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_369stream_AD, 0, __pyx_mstate_global->__pyx_n_u_stream_AD, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[210])); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 77, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_AD, __pyx_t_4) < (0)) __PYX_ERR(5, 77, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_371stream_ADD, 0, __pyx_mstate_global->__pyx_n_u_stream_ADD, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[211])); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 113, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_ADD, __pyx_t_4) < (0)) __PYX_ERR(5, 113, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+  __pyx_t_4 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 146, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_7 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 146, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+
+  __pyx_t_20 = PyTuple_Pack(2, __pyx_t_4, __pyx_t_7); if (unlikely(!__pyx_t_20)) __PYX_ERR(5, 144, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_20);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_373stream_ADOSC, 0, __pyx_mstate_global->__pyx_n_u_stream_ADOSC, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[212])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 144, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_7, __pyx_t_20);
+  __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_ADOSC, __pyx_t_7) < (0)) __PYX_ERR(5, 144, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 185, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+
+  __pyx_t_20 = PyTuple_Pack(1, __pyx_t_7); if (unlikely(!__pyx_t_20)) __PYX_ERR(5, 183, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_20);
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_375stream_ADX, 0, __pyx_mstate_global->__pyx_n_u_stream_ADX, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[213])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 183, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_7, __pyx_t_20);
+  __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_ADX, __pyx_t_7) < (0)) __PYX_ERR(5, 183, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 220, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+
+  __pyx_t_20 = PyTuple_Pack(1, __pyx_t_7); if (unlikely(!__pyx_t_20)) __PYX_ERR(5, 218, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_20);
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_377stream_ADXR, 0, __pyx_mstate_global->__pyx_n_u_stream_ADXR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[214])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 218, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_7, __pyx_t_20);
+  __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_ADXR, __pyx_t_7) < (0)) __PYX_ERR(5, 218, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 255, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __pyx_t_20 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_20)) __PYX_ERR(5, 255, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_20);
+  __pyx_t_4 = __Pyx_PyLong_From_int(((int)0)); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 255, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+
+  __pyx_t_15 = PyTuple_Pack(3, __pyx_t_7, __pyx_t_20, __pyx_t_4); if (unlikely(!__pyx_t_15)) __PYX_ERR(5, 253, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_15);
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_379stream_APO, 0, __pyx_mstate_global->__pyx_n_u_stream_APO, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[215])); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 253, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_4, __pyx_t_15);
+  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_APO, __pyx_t_4) < (0)) __PYX_ERR(5, 253, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+  __pyx_t_4 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 286, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+
+  __pyx_t_15 = PyTuple_Pack(1, __pyx_t_4); if (unlikely(!__pyx_t_15)) __PYX_ERR(5, 284, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_15);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_381stream_AROON, 0, __pyx_mstate_global->__pyx_n_u_stream_AROON, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[216])); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 284, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_4, __pyx_t_15);
+  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_AROON, __pyx_t_4) < (0)) __PYX_ERR(5, 284, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+  __pyx_t_4 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 321, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+
+  __pyx_t_15 = PyTuple_Pack(1, __pyx_t_4); if (unlikely(!__pyx_t_15)) __PYX_ERR(5, 319, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_15);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_383stream_AROONOSC, 0, __pyx_mstate_global->__pyx_n_u_stream_AROONOSC, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[217])); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 319, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_4, __pyx_t_15);
+  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_AROONOSC, __pyx_t_4) < (0)) __PYX_ERR(5, 319, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_385stream_ASIN, 0, __pyx_mstate_global->__pyx_n_u_stream_ASIN, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[218])); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 351, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_ASIN, __pyx_t_4) < (0)) __PYX_ERR(5, 351, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_387stream_ATAN, 0, __pyx_mstate_global->__pyx_n_u_stream_ATAN, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[219])); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 378, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_ATAN, __pyx_t_4) < (0)) __PYX_ERR(5, 378, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+  __pyx_t_4 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 407, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+
+  __pyx_t_15 = PyTuple_Pack(1, __pyx_t_4); if (unlikely(!__pyx_t_15)) __PYX_ERR(5, 405, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_15);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_389stream_ATR, 0, __pyx_mstate_global->__pyx_n_u_stream_ATR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[220])); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 405, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_4, __pyx_t_15);
+  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_ATR, __pyx_t_4) < (0)) __PYX_ERR(5, 405, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_391stream_AVGPRICE, 0, __pyx_mstate_global->__pyx_n_u_stream_AVGPRICE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[221])); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 440, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_AVGPRICE, __pyx_t_4) < (0)) __PYX_ERR(5, 440, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+  __pyx_t_4 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 478, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+
+  __pyx_t_15 = PyTuple_Pack(1, __pyx_t_4); if (unlikely(!__pyx_t_15)) __PYX_ERR(5, 476, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_15);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_393stream_AVGDEV, 0, __pyx_mstate_global->__pyx_n_u_stream_AVGDEV, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[222])); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 476, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_4, __pyx_t_15);
+  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_AVGDEV, __pyx_t_4) < (0)) __PYX_ERR(5, 476, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+  __pyx_t_4 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 507, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_15 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_15)) __PYX_ERR(5, 507, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_15);
+  __pyx_t_20 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_20)) __PYX_ERR(5, 507, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_20);
+  __pyx_t_7 = __Pyx_PyLong_From_int(((int)0)); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 507, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+
+  __pyx_t_6 = PyTuple_Pack(4, __pyx_t_4, __pyx_t_15, __pyx_t_20, __pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 505, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
+  __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_395stream_BBANDS, 0, __pyx_mstate_global->__pyx_n_u_stream_BBANDS, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[223])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 505, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_7, __pyx_t_6);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_BBANDS, __pyx_t_7) < (0)) __PYX_ERR(5, 505, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 545, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+
+  __pyx_t_6 = PyTuple_Pack(1, __pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 543, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_397stream_BETA, 0, __pyx_mstate_global->__pyx_n_u_stream_BETA, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[224])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 543, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_7, __pyx_t_6);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_BETA, __pyx_t_7) < (0)) __PYX_ERR(5, 543, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_399stream_BOP, 0, __pyx_mstate_global->__pyx_n_u_stream_BOP, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[225])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 576, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_BOP, __pyx_t_7) < (0)) __PYX_ERR(5, 576, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 614, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+
+  __pyx_t_6 = PyTuple_Pack(1, __pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 612, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_401stream_CCI, 0, __pyx_mstate_global->__pyx_n_u_stream_CCI, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[226])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 612, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_7, __pyx_t_6);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CCI, __pyx_t_7) < (0)) __PYX_ERR(5, 612, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_403stream_CDL2CROWS, 0, __pyx_mstate_global->__pyx_n_u_stream_CDL2CROWS, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[227])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 647, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDL2CROWS, __pyx_t_7) < (0)) __PYX_ERR(5, 647, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_405stream_CDL3BLACKCROWS, 0, __pyx_mstate_global->__pyx_n_u_stream_CDL3BLACKCROWS, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[228])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 683, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDL3BLACKCROWS, __pyx_t_7) < (0)) __PYX_ERR(5, 683, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_407stream_CDL3INSIDE, 0, __pyx_mstate_global->__pyx_n_u_stream_CDL3INSIDE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[229])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 719, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDL3INSIDE, __pyx_t_7) < (0)) __PYX_ERR(5, 719, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_409stream_CDL3LINESTRIKE, 0, __pyx_mstate_global->__pyx_n_u_stream_CDL3LINESTRIKE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[230])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 755, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDL3LINESTRIKE, __pyx_t_7) < (0)) __PYX_ERR(5, 755, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_411stream_CDL3OUTSIDE, 0, __pyx_mstate_global->__pyx_n_u_stream_CDL3OUTSIDE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[231])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 791, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDL3OUTSIDE, __pyx_t_7) < (0)) __PYX_ERR(5, 791, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_413stream_CDL3STARSINSOUTH, 0, __pyx_mstate_global->__pyx_n_u_stream_CDL3STARSINSOUTH, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[232])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 827, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDL3STARSINSOUTH, __pyx_t_7) < (0)) __PYX_ERR(5, 827, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_415stream_CDL3WHITESOLDIERS, 0, __pyx_mstate_global->__pyx_n_u_stream_CDL3WHITESOLDIERS, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[233])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 863, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDL3WHITESOLDIERS, __pyx_t_7) < (0)) __PYX_ERR(5, 863, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = PyFloat_FromDouble(((double)0.3)); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 901, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+
+  __pyx_t_6 = PyTuple_Pack(1, __pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 899, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_417stream_CDLABANDONEDBABY, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLABANDONEDBABY, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[234])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 899, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_7, __pyx_t_6);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLABANDONEDBABY, __pyx_t_7) < (0)) __PYX_ERR(5, 899, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_419stream_CDLADVANCEBLOCK, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLADVANCEBLOCK, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[235])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 937, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLADVANCEBLOCK, __pyx_t_7) < (0)) __PYX_ERR(5, 937, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_421stream_CDLBELTHOLD, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLBELTHOLD, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[236])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 973, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLBELTHOLD, __pyx_t_7) < (0)) __PYX_ERR(5, 973, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_423stream_CDLBREAKAWAY, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLBREAKAWAY, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[237])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 1009, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLBREAKAWAY, __pyx_t_7) < (0)) __PYX_ERR(5, 1009, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_425stream_CDLCLOSINGMARUBOZU, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLCLOSINGMARUBOZU, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[238])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 1045, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLCLOSINGMARUBOZU, __pyx_t_7) < (0)) __PYX_ERR(5, 1045, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_427stream_CDLCONCEALBABYSWALL, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLCONCEALBABYSWALL, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[239])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 1081, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLCONCEALBABYSWALL, __pyx_t_7) < (0)) __PYX_ERR(5, 1081, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_429stream_CDLCOUNTERATTACK, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLCOUNTERATTACK, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[240])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 1117, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLCOUNTERATTACK, __pyx_t_7) < (0)) __PYX_ERR(5, 1117, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = PyFloat_FromDouble(((double)0.5)); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 1155, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+
+  __pyx_t_6 = PyTuple_Pack(1, __pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 1153, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_431stream_CDLDARKCLOUDCOVER, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLDARKCLOUDCOVER, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[241])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 1153, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_7, __pyx_t_6);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLDARKCLOUDCOVER, __pyx_t_7) < (0)) __PYX_ERR(5, 1153, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_433stream_CDLDOJI, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLDOJI, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[242])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 1191, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLDOJI, __pyx_t_7) < (0)) __PYX_ERR(5, 1191, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_435stream_CDLDOJISTAR, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLDOJISTAR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[243])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 1227, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLDOJISTAR, __pyx_t_7) < (0)) __PYX_ERR(5, 1227, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_437stream_CDLDRAGONFLYDOJI, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLDRAGONFLYDOJI, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[244])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 1263, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLDRAGONFLYDOJI, __pyx_t_7) < (0)) __PYX_ERR(5, 1263, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_439stream_CDLENGULFING, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLENGULFING, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[245])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 1299, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLENGULFING, __pyx_t_7) < (0)) __PYX_ERR(5, 1299, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = PyFloat_FromDouble(((double)0.3)); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 1337, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+
+  __pyx_t_6 = PyTuple_Pack(1, __pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 1335, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_441stream_CDLEVENINGDOJISTAR, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLEVENINGDOJISTAR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[246])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 1335, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_7, __pyx_t_6);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLEVENINGDOJISTAR, __pyx_t_7) < (0)) __PYX_ERR(5, 1335, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = PyFloat_FromDouble(((double)0.3)); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 1375, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+
+  __pyx_t_6 = PyTuple_Pack(1, __pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 1373, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_443stream_CDLEVENINGSTAR, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLEVENINGSTAR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[247])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 1373, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_7, __pyx_t_6);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLEVENINGSTAR, __pyx_t_7) < (0)) __PYX_ERR(5, 1373, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_445stream_CDLGAPSIDESIDEWHITE, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLGAPSIDESIDEWHITE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[248])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 1411, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLGAPSIDESIDEWHITE, __pyx_t_7) < (0)) __PYX_ERR(5, 1411, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_447stream_CDLGRAVESTONEDOJI, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLGRAVESTONEDOJI, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[249])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 1447, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLGRAVESTONEDOJI, __pyx_t_7) < (0)) __PYX_ERR(5, 1447, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_449stream_CDLHAMMER, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLHAMMER, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[250])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 1483, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLHAMMER, __pyx_t_7) < (0)) __PYX_ERR(5, 1483, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_451stream_CDLHANGINGMAN, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLHANGINGMAN, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[251])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 1519, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLHANGINGMAN, __pyx_t_7) < (0)) __PYX_ERR(5, 1519, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_453stream_CDLHARAMI, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLHARAMI, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[252])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 1555, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLHARAMI, __pyx_t_7) < (0)) __PYX_ERR(5, 1555, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_455stream_CDLHARAMICROSS, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLHARAMICROSS, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[253])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 1591, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLHARAMICROSS, __pyx_t_7) < (0)) __PYX_ERR(5, 1591, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_457stream_CDLHIGHWAVE, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLHIGHWAVE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[254])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 1627, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLHIGHWAVE, __pyx_t_7) < (0)) __PYX_ERR(5, 1627, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_459stream_CDLHIKKAKE, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLHIKKAKE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[255])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 1663, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLHIKKAKE, __pyx_t_7) < (0)) __PYX_ERR(5, 1663, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_461stream_CDLHIKKAKEMOD, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLHIKKAKEMOD, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[256])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 1699, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLHIKKAKEMOD, __pyx_t_7) < (0)) __PYX_ERR(5, 1699, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_463stream_CDLHOMINGPIGEON, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLHOMINGPIGEON, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[257])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 1735, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLHOMINGPIGEON, __pyx_t_7) < (0)) __PYX_ERR(5, 1735, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_465stream_CDLIDENTICAL3CROWS, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLIDENTICAL3CROWS, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[258])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 1771, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLIDENTICAL3CROWS, __pyx_t_7) < (0)) __PYX_ERR(5, 1771, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_467stream_CDLINNECK, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLINNECK, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[259])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 1807, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLINNECK, __pyx_t_7) < (0)) __PYX_ERR(5, 1807, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_469stream_CDLINVERTEDHAMMER, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLINVERTEDHAMMER, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[260])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 1843, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLINVERTEDHAMMER, __pyx_t_7) < (0)) __PYX_ERR(5, 1843, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_471stream_CDLKICKING, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLKICKING, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[261])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 1879, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLKICKING, __pyx_t_7) < (0)) __PYX_ERR(5, 1879, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_473stream_CDLKICKINGBYLENGTH, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLKICKINGBYLENGTH, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[262])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 1915, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLKICKINGBYLENGTH, __pyx_t_7) < (0)) __PYX_ERR(5, 1915, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_475stream_CDLLADDERBOTTOM, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLLADDERBOTTOM, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[263])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 1951, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLLADDERBOTTOM, __pyx_t_7) < (0)) __PYX_ERR(5, 1951, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_477stream_CDLLONGLEGGEDDOJI, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLLONGLEGGEDDOJI, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[264])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 1987, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLLONGLEGGEDDOJI, __pyx_t_7) < (0)) __PYX_ERR(5, 1987, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_479stream_CDLLONGLINE, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLLONGLINE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[265])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 2023, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLLONGLINE, __pyx_t_7) < (0)) __PYX_ERR(5, 2023, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_481stream_CDLMARUBOZU, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLMARUBOZU, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[266])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 2059, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLMARUBOZU, __pyx_t_7) < (0)) __PYX_ERR(5, 2059, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_483stream_CDLMATCHINGLOW, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLMATCHINGLOW, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[267])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 2095, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLMATCHINGLOW, __pyx_t_7) < (0)) __PYX_ERR(5, 2095, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = PyFloat_FromDouble(((double)0.5)); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 2133, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+
+  __pyx_t_6 = PyTuple_Pack(1, __pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 2131, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_485stream_CDLMATHOLD, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLMATHOLD, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[268])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 2131, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_7, __pyx_t_6);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLMATHOLD, __pyx_t_7) < (0)) __PYX_ERR(5, 2131, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = PyFloat_FromDouble(((double)0.3)); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 2171, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+
+  __pyx_t_6 = PyTuple_Pack(1, __pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 2169, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_487stream_CDLMORNINGDOJISTAR, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLMORNINGDOJISTAR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[269])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 2169, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_7, __pyx_t_6);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLMORNINGDOJISTAR, __pyx_t_7) < (0)) __PYX_ERR(5, 2169, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = PyFloat_FromDouble(((double)0.3)); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 2209, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+
+  __pyx_t_6 = PyTuple_Pack(1, __pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 2207, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_489stream_CDLMORNINGSTAR, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLMORNINGSTAR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[270])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 2207, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_7, __pyx_t_6);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLMORNINGSTAR, __pyx_t_7) < (0)) __PYX_ERR(5, 2207, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_491stream_CDLONNECK, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLONNECK, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[271])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 2245, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLONNECK, __pyx_t_7) < (0)) __PYX_ERR(5, 2245, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_493stream_CDLPIERCING, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLPIERCING, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[272])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 2281, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLPIERCING, __pyx_t_7) < (0)) __PYX_ERR(5, 2281, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_495stream_CDLRICKSHAWMAN, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLRICKSHAWMAN, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[273])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 2317, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLRICKSHAWMAN, __pyx_t_7) < (0)) __PYX_ERR(5, 2317, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_497stream_CDLRISEFALL3METHODS, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLRISEFALL3METHODS, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[274])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 2353, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLRISEFALL3METHODS, __pyx_t_7) < (0)) __PYX_ERR(5, 2353, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_499stream_CDLSEPARATINGLINES, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLSEPARATINGLINES, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[275])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 2389, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLSEPARATINGLINES, __pyx_t_7) < (0)) __PYX_ERR(5, 2389, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_501stream_CDLSHOOTINGSTAR, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLSHOOTINGSTAR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[276])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 2425, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLSHOOTINGSTAR, __pyx_t_7) < (0)) __PYX_ERR(5, 2425, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_503stream_CDLSHORTLINE, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLSHORTLINE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[277])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 2461, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLSHORTLINE, __pyx_t_7) < (0)) __PYX_ERR(5, 2461, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_505stream_CDLSPINNINGTOP, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLSPINNINGTOP, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[278])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 2497, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLSPINNINGTOP, __pyx_t_7) < (0)) __PYX_ERR(5, 2497, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_507stream_CDLSTALLEDPATTERN, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLSTALLEDPATTERN, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[279])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 2533, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLSTALLEDPATTERN, __pyx_t_7) < (0)) __PYX_ERR(5, 2533, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_509stream_CDLSTICKSANDWICH, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLSTICKSANDWICH, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[280])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 2569, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLSTICKSANDWICH, __pyx_t_7) < (0)) __PYX_ERR(5, 2569, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_511stream_CDLTAKURI, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLTAKURI, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[281])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 2605, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLTAKURI, __pyx_t_7) < (0)) __PYX_ERR(5, 2605, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_513stream_CDLTASUKIGAP, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLTASUKIGAP, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[282])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 2641, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLTASUKIGAP, __pyx_t_7) < (0)) __PYX_ERR(5, 2641, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_515stream_CDLTHRUSTING, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLTHRUSTING, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[283])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 2677, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLTHRUSTING, __pyx_t_7) < (0)) __PYX_ERR(5, 2677, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_517stream_CDLTRISTAR, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLTRISTAR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[284])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 2713, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLTRISTAR, __pyx_t_7) < (0)) __PYX_ERR(5, 2713, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_519stream_CDLUNIQUE3RIVER, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLUNIQUE3RIVER, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[285])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 2749, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLUNIQUE3RIVER, __pyx_t_7) < (0)) __PYX_ERR(5, 2749, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_521stream_CDLUPSIDEGAP2CROWS, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLUPSIDEGAP2CROWS, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[286])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 2785, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLUPSIDEGAP2CROWS, __pyx_t_7) < (0)) __PYX_ERR(5, 2785, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_523stream_CDLXSIDEGAP3METHODS, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLXSIDEGAP3METHODS, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[287])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 2821, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLXSIDEGAP3METHODS, __pyx_t_7) < (0)) __PYX_ERR(5, 2821, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_525stream_CEIL, 0, __pyx_mstate_global->__pyx_n_u_stream_CEIL, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[288])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 2857, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CEIL, __pyx_t_7) < (0)) __PYX_ERR(5, 2857, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 2886, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+
+  __pyx_t_6 = PyTuple_Pack(1, __pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 2884, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_527stream_CMO, 0, __pyx_mstate_global->__pyx_n_u_stream_CMO, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[289])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 2884, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_7, __pyx_t_6);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CMO, __pyx_t_7) < (0)) __PYX_ERR(5, 2884, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 2915, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+
+  __pyx_t_6 = PyTuple_Pack(1, __pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 2913, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_529stream_CORREL, 0, __pyx_mstate_global->__pyx_n_u_stream_CORREL, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[290])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 2913, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_7, __pyx_t_6);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CORREL, __pyx_t_7) < (0)) __PYX_ERR(5, 2913, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_531stream_COS, 0, __pyx_mstate_global->__pyx_n_u_stream_COS, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[291])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 2946, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_COS, __pyx_t_7) < (0)) __PYX_ERR(5, 2946, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_533stream_COSH, 0, __pyx_mstate_global->__pyx_n_u_stream_COSH, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[292])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 2973, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_COSH, __pyx_t_7) < (0)) __PYX_ERR(5, 2973, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 3002, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+
+  __pyx_t_6 = PyTuple_Pack(1, __pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 3000, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_535stream_DEMA, 0, __pyx_mstate_global->__pyx_n_u_stream_DEMA, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[293])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 3000, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_7, __pyx_t_6);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_DEMA, __pyx_t_7) < (0)) __PYX_ERR(5, 3000, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_537stream_DIV, 0, __pyx_mstate_global->__pyx_n_u_stream_DIV, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[294])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 3029, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_DIV, __pyx_t_7) < (0)) __PYX_ERR(5, 3029, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 3062, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+
+  __pyx_t_6 = PyTuple_Pack(1, __pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 3060, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_539stream_DX, 0, __pyx_mstate_global->__pyx_n_u_stream_DX, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[295])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 3060, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_7, __pyx_t_6);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_DX, __pyx_t_7) < (0)) __PYX_ERR(5, 3060, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 3097, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+
+  __pyx_t_6 = PyTuple_Pack(1, __pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 3095, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_541stream_EMA, 0, __pyx_mstate_global->__pyx_n_u_stream_EMA, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[296])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 3095, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_7, __pyx_t_6);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_EMA, __pyx_t_7) < (0)) __PYX_ERR(5, 3095, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_543stream_EXP, 0, __pyx_mstate_global->__pyx_n_u_stream_EXP, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[297])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 3124, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_EXP, __pyx_t_7) < (0)) __PYX_ERR(5, 3124, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_545stream_FLOOR, 0, __pyx_mstate_global->__pyx_n_u_stream_FLOOR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[298])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 3151, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_FLOOR, __pyx_t_7) < (0)) __PYX_ERR(5, 3151, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_547stream_HT_DCPERIOD, 0, __pyx_mstate_global->__pyx_n_u_stream_HT_DCPERIOD, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[299])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 3178, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_HT_DCPERIOD, __pyx_t_7) < (0)) __PYX_ERR(5, 3178, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_549stream_HT_DCPHASE, 0, __pyx_mstate_global->__pyx_n_u_stream_HT_DCPHASE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[300])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 3205, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_HT_DCPHASE, __pyx_t_7) < (0)) __PYX_ERR(5, 3205, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_551stream_HT_PHASOR, 0, __pyx_mstate_global->__pyx_n_u_stream_HT_PHASOR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[301])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 3232, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_HT_PHASOR, __pyx_t_7) < (0)) __PYX_ERR(5, 3232, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_553stream_HT_SINE, 0, __pyx_mstate_global->__pyx_n_u_stream_HT_SINE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[302])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 3262, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_HT_SINE, __pyx_t_7) < (0)) __PYX_ERR(5, 3262, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_555stream_HT_TRENDLINE, 0, __pyx_mstate_global->__pyx_n_u_stream_HT_TRENDLINE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[303])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 3292, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_HT_TRENDLINE, __pyx_t_7) < (0)) __PYX_ERR(5, 3292, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_557stream_HT_TRENDMODE, 0, __pyx_mstate_global->__pyx_n_u_stream_HT_TRENDMODE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[304])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 3319, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_HT_TRENDMODE, __pyx_t_7) < (0)) __PYX_ERR(5, 3319, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 3348, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+
+  __pyx_t_6 = PyTuple_Pack(1, __pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 3346, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_559stream_IMI, 0, __pyx_mstate_global->__pyx_n_u_stream_IMI, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[305])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 3346, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_7, __pyx_t_6);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_IMI, __pyx_t_7) < (0)) __PYX_ERR(5, 3346, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 3380, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+
+  __pyx_t_6 = PyTuple_Pack(1, __pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 3378, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_561stream_KAMA, 0, __pyx_mstate_global->__pyx_n_u_stream_KAMA, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[306])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 3378, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_7, __pyx_t_6);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_KAMA, __pyx_t_7) < (0)) __PYX_ERR(5, 3378, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 3409, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+
+  __pyx_t_6 = PyTuple_Pack(1, __pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 3407, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_563stream_LINEARREG, 0, __pyx_mstate_global->__pyx_n_u_stream_LINEARREG, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[307])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 3407, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_7, __pyx_t_6);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_LINEARREG, __pyx_t_7) < (0)) __PYX_ERR(5, 3407, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 3438, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+
+  __pyx_t_6 = PyTuple_Pack(1, __pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 3436, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_565stream_LINEARREG_ANGLE, 0, __pyx_mstate_global->__pyx_n_u_stream_LINEARREG_ANGLE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[308])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 3436, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_7, __pyx_t_6);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_LINEARREG_ANGLE, __pyx_t_7) < (0)) __PYX_ERR(5, 3436, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 3467, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+
+  __pyx_t_6 = PyTuple_Pack(1, __pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 3465, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_567stream_LINEARREG_INTERCEPT, 0, __pyx_mstate_global->__pyx_n_u_stream_LINEARREG_INTERCEPT, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[309])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 3465, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_7, __pyx_t_6);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_LINEARREG_INTERCEPT, __pyx_t_7) < (0)) __PYX_ERR(5, 3465, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 3496, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+
+  __pyx_t_6 = PyTuple_Pack(1, __pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 3494, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_569stream_LINEARREG_SLOPE, 0, __pyx_mstate_global->__pyx_n_u_stream_LINEARREG_SLOPE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[310])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 3494, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_7, __pyx_t_6);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_LINEARREG_SLOPE, __pyx_t_7) < (0)) __PYX_ERR(5, 3494, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_571stream_LN, 0, __pyx_mstate_global->__pyx_n_u_stream_LN, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[311])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 3523, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_LN, __pyx_t_7) < (0)) __PYX_ERR(5, 3523, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_573stream_LOG10, 0, __pyx_mstate_global->__pyx_n_u_stream_LOG10, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[312])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 3550, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_LOG10, __pyx_t_7) < (0)) __PYX_ERR(5, 3550, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 3579, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __pyx_t_6 = __Pyx_PyLong_From_int(((int)0)); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 3579, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+
+  __pyx_t_20 = PyTuple_Pack(2, __pyx_t_7, __pyx_t_6); if (unlikely(!__pyx_t_20)) __PYX_ERR(5, 3577, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_20);
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_575stream_MA, 0, __pyx_mstate_global->__pyx_n_u_stream_MA, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[313])); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 3577, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_6, __pyx_t_20);
+  __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_MA, __pyx_t_6) < (0)) __PYX_ERR(5, 3577, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+
+  __pyx_t_6 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 3609, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __pyx_t_20 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_20)) __PYX_ERR(5, 3609, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_20);
+  __pyx_t_7 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 3609, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+
+  __pyx_t_15 = PyTuple_Pack(3, __pyx_t_6, __pyx_t_20, __pyx_t_7); if (unlikely(!__pyx_t_15)) __PYX_ERR(5, 3607, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_15);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_577stream_MACD, 0, __pyx_mstate_global->__pyx_n_u_stream_MACD, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[314])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 3607, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_7, __pyx_t_15);
+  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_MACD, __pyx_t_7) < (0)) __PYX_ERR(5, 3607, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 3646, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __pyx_t_15 = __Pyx_PyLong_From_int(((int)0)); if (unlikely(!__pyx_t_15)) __PYX_ERR(5, 3646, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_15);
+  __pyx_t_20 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_20)) __PYX_ERR(5, 3646, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_20);
+  __pyx_t_6 = __Pyx_PyLong_From_int(((int)0)); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 3646, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __pyx_t_4 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 3646, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_3 = __Pyx_PyLong_From_int(((int)0)); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 3646, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+
+  __pyx_t_2 = PyTuple_Pack(6, __pyx_t_7, __pyx_t_15, __pyx_t_20, __pyx_t_6, __pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 3644, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
+  __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_579stream_MACDEXT, 0, __pyx_mstate_global->__pyx_n_u_stream_MACDEXT, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[315])); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 3644, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_2);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_MACDEXT, __pyx_t_3) < (0)) __PYX_ERR(5, 3644, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  __pyx_t_3 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 3686, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+
+  __pyx_t_2 = PyTuple_Pack(1, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 3684, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_581stream_MACDFIX, 0, __pyx_mstate_global->__pyx_n_u_stream_MACDFIX, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[316])); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 3684, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_2);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_MACDFIX, __pyx_t_3) < (0)) __PYX_ERR(5, 3684, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  __pyx_t_3 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 3721, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_2 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 3721, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+
+  __pyx_t_4 = PyTuple_Pack(2, __pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 3719, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_583stream_MAMA, 0, __pyx_mstate_global->__pyx_n_u_stream_MAMA, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[317])); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 3719, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_4);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_MAMA, __pyx_t_2) < (0)) __PYX_ERR(5, 3719, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  __pyx_t_2 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 3754, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_4 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 3754, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_3 = __Pyx_PyLong_From_int(((int)0)); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 3754, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+
+  __pyx_t_6 = PyTuple_Pack(3, __pyx_t_2, __pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 3752, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_585stream_MAVP, 0, __pyx_mstate_global->__pyx_n_u_stream_MAVP, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[318])); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 3752, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_6);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_MAVP, __pyx_t_3) < (0)) __PYX_ERR(5, 3752, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  __pyx_t_3 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 3789, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+
+  __pyx_t_6 = PyTuple_Pack(1, __pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 3787, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_587stream_MAX, 0, __pyx_mstate_global->__pyx_n_u_stream_MAX, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[319])); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 3787, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_6);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_MAX, __pyx_t_3) < (0)) __PYX_ERR(5, 3787, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  __pyx_t_3 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 3818, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+
+  __pyx_t_6 = PyTuple_Pack(1, __pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 3816, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_589stream_MAXINDEX, 0, __pyx_mstate_global->__pyx_n_u_stream_MAXINDEX, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[320])); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 3816, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_6);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_MAXINDEX, __pyx_t_3) < (0)) __PYX_ERR(5, 3816, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_591stream_MEDPRICE, 0, __pyx_mstate_global->__pyx_n_u_stream_MEDPRICE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[321])); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 3845, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_MEDPRICE, __pyx_t_3) < (0)) __PYX_ERR(5, 3845, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  __pyx_t_3 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 3877, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+
+  __pyx_t_6 = PyTuple_Pack(1, __pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 3875, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_593stream_MFI, 0, __pyx_mstate_global->__pyx_n_u_stream_MFI, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[322])); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 3875, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_6);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_MFI, __pyx_t_3) < (0)) __PYX_ERR(5, 3875, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  __pyx_t_3 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 3915, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+
+  __pyx_t_6 = PyTuple_Pack(1, __pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 3913, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_595stream_MIDPOINT, 0, __pyx_mstate_global->__pyx_n_u_stream_MIDPOINT, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[323])); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 3913, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_6);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_MIDPOINT, __pyx_t_3) < (0)) __PYX_ERR(5, 3913, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  __pyx_t_3 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 3944, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+
+  __pyx_t_6 = PyTuple_Pack(1, __pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 3942, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_597stream_MIDPRICE, 0, __pyx_mstate_global->__pyx_n_u_stream_MIDPRICE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[324])); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 3942, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_6);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_MIDPRICE, __pyx_t_3) < (0)) __PYX_ERR(5, 3942, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  __pyx_t_3 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 3976, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+
+  __pyx_t_6 = PyTuple_Pack(1, __pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 3974, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_599stream_MIN, 0, __pyx_mstate_global->__pyx_n_u_stream_MIN, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[325])); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 3974, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_6);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_MIN, __pyx_t_3) < (0)) __PYX_ERR(5, 3974, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  __pyx_t_3 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 4005, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+
+  __pyx_t_6 = PyTuple_Pack(1, __pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 4003, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_601stream_MININDEX, 0, __pyx_mstate_global->__pyx_n_u_stream_MININDEX, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[326])); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 4003, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_6);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_MININDEX, __pyx_t_3) < (0)) __PYX_ERR(5, 4003, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  __pyx_t_3 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 4034, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+
+  __pyx_t_6 = PyTuple_Pack(1, __pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 4032, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_603stream_MINMAX, 0, __pyx_mstate_global->__pyx_n_u_stream_MINMAX, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[327])); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 4032, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_6);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_MINMAX, __pyx_t_3) < (0)) __PYX_ERR(5, 4032, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  __pyx_t_3 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 4066, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+
+  __pyx_t_6 = PyTuple_Pack(1, __pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 4064, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_605stream_MINMAXINDEX, 0, __pyx_mstate_global->__pyx_n_u_stream_MINMAXINDEX, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[328])); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 4064, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_6);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_MINMAXINDEX, __pyx_t_3) < (0)) __PYX_ERR(5, 4064, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  __pyx_t_3 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 4098, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+
+  __pyx_t_6 = PyTuple_Pack(1, __pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 4096, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_607stream_MINUS_DI, 0, __pyx_mstate_global->__pyx_n_u_stream_MINUS_DI, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[329])); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 4096, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_6);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_MINUS_DI, __pyx_t_3) < (0)) __PYX_ERR(5, 4096, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  __pyx_t_3 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 4133, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+
+  __pyx_t_6 = PyTuple_Pack(1, __pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 4131, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_609stream_MINUS_DM, 0, __pyx_mstate_global->__pyx_n_u_stream_MINUS_DM, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[330])); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 4131, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_6);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_MINUS_DM, __pyx_t_3) < (0)) __PYX_ERR(5, 4131, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  __pyx_t_3 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 4165, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+
+  __pyx_t_6 = PyTuple_Pack(1, __pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 4163, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_611stream_MOM, 0, __pyx_mstate_global->__pyx_n_u_stream_MOM, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[331])); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 4163, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_6);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_MOM, __pyx_t_3) < (0)) __PYX_ERR(5, 4163, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_613stream_MULT, 0, __pyx_mstate_global->__pyx_n_u_stream_MULT, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[332])); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 4192, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_MULT, __pyx_t_3) < (0)) __PYX_ERR(5, 4192, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  __pyx_t_3 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 4225, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+
+  __pyx_t_6 = PyTuple_Pack(1, __pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 4223, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_615stream_NATR, 0, __pyx_mstate_global->__pyx_n_u_stream_NATR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[333])); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 4223, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_6);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_NATR, __pyx_t_3) < (0)) __PYX_ERR(5, 4223, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_617stream_OBV, 0, __pyx_mstate_global->__pyx_n_u_stream_OBV, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[334])); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 4258, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_OBV, __pyx_t_3) < (0)) __PYX_ERR(5, 4258, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  __pyx_t_3 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 4291, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+
+  __pyx_t_6 = PyTuple_Pack(1, __pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 4289, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_619stream_PLUS_DI, 0, __pyx_mstate_global->__pyx_n_u_stream_PLUS_DI, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[335])); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 4289, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_6);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_PLUS_DI, __pyx_t_3) < (0)) __PYX_ERR(5, 4289, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  __pyx_t_3 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 4326, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+
+  __pyx_t_6 = PyTuple_Pack(1, __pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 4324, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_621stream_PLUS_DM, 0, __pyx_mstate_global->__pyx_n_u_stream_PLUS_DM, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[336])); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 4324, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_6);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_PLUS_DM, __pyx_t_3) < (0)) __PYX_ERR(5, 4324, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  __pyx_t_3 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 4358, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_6 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 4358, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __pyx_t_4 = __Pyx_PyLong_From_int(((int)0)); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 4358, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+
+  __pyx_t_2 = PyTuple_Pack(3, __pyx_t_3, __pyx_t_6, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 4356, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_623stream_PPO, 0, __pyx_mstate_global->__pyx_n_u_stream_PPO, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[337])); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 4356, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_4, __pyx_t_2);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_PPO, __pyx_t_4) < (0)) __PYX_ERR(5, 4356, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+  __pyx_t_4 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 4389, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+
+  __pyx_t_2 = PyTuple_Pack(1, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 4387, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_625stream_ROC, 0, __pyx_mstate_global->__pyx_n_u_stream_ROC, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[338])); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 4387, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_4, __pyx_t_2);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_ROC, __pyx_t_4) < (0)) __PYX_ERR(5, 4387, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+  __pyx_t_4 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 4418, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+
+  __pyx_t_2 = PyTuple_Pack(1, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 4416, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_627stream_ROCP, 0, __pyx_mstate_global->__pyx_n_u_stream_ROCP, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[339])); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 4416, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_4, __pyx_t_2);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_ROCP, __pyx_t_4) < (0)) __PYX_ERR(5, 4416, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+  __pyx_t_4 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 4447, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+
+  __pyx_t_2 = PyTuple_Pack(1, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 4445, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_629stream_ROCR, 0, __pyx_mstate_global->__pyx_n_u_stream_ROCR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[340])); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 4445, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_4, __pyx_t_2);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_ROCR, __pyx_t_4) < (0)) __PYX_ERR(5, 4445, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+  __pyx_t_4 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 4476, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+
+  __pyx_t_2 = PyTuple_Pack(1, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 4474, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_631stream_ROCR100, 0, __pyx_mstate_global->__pyx_n_u_stream_ROCR100, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[341])); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 4474, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_4, __pyx_t_2);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_ROCR100, __pyx_t_4) < (0)) __PYX_ERR(5, 4474, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+  __pyx_t_4 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 4505, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+
+  __pyx_t_2 = PyTuple_Pack(1, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 4503, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_633stream_RSI, 0, __pyx_mstate_global->__pyx_n_u_stream_RSI, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[342])); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 4503, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_4, __pyx_t_2);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_RSI, __pyx_t_4) < (0)) __PYX_ERR(5, 4503, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+  __pyx_t_4 = PyFloat_FromDouble(((double)0.02)); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 4534, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_2 = PyFloat_FromDouble(((double)0.2)); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 4534, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+
+  __pyx_t_6 = PyTuple_Pack(2, __pyx_t_4, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 4532, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_635stream_SAR, 0, __pyx_mstate_global->__pyx_n_u_stream_SAR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[343])); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 4532, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_6);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_SAR, __pyx_t_2) < (0)) __PYX_ERR(5, 4532, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  __pyx_t_2 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 4567, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_6 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 4567, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __pyx_t_4 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 4567, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_3 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 4567, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_20 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_20)) __PYX_ERR(5, 4567, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_20);
+  __pyx_t_15 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_15)) __PYX_ERR(5, 4567, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_15);
+  __pyx_t_7 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 4567, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __pyx_t_16 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_16)) __PYX_ERR(5, 4567, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_16);
+
+  __pyx_t_19 = PyTuple_Pack(8, __pyx_t_2, __pyx_t_6, __pyx_t_4, __pyx_t_3, __pyx_t_20, __pyx_t_15, __pyx_t_7, __pyx_t_16); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 4565, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_19);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
+  __pyx_t_16 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_637stream_SAREXT, 0, __pyx_mstate_global->__pyx_n_u_stream_SAREXT, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[344])); if (unlikely(!__pyx_t_16)) __PYX_ERR(5, 4565, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_16);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_16, __pyx_t_19);
+  __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_SAREXT, __pyx_t_16) < (0)) __PYX_ERR(5, 4565, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
+
+  __pyx_t_16 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_639stream_SIN, 0, __pyx_mstate_global->__pyx_n_u_stream_SIN, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[345])); if (unlikely(!__pyx_t_16)) __PYX_ERR(5, 4604, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_16);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_SIN, __pyx_t_16) < (0)) __PYX_ERR(5, 4604, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
+
+  __pyx_t_16 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_641stream_SINH, 0, __pyx_mstate_global->__pyx_n_u_stream_SINH, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[346])); if (unlikely(!__pyx_t_16)) __PYX_ERR(5, 4631, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_16);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_SINH, __pyx_t_16) < (0)) __PYX_ERR(5, 4631, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
+
+  __pyx_t_16 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_16)) __PYX_ERR(5, 4660, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_16);
+
+  __pyx_t_19 = PyTuple_Pack(1, __pyx_t_16); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 4658, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_19);
+  __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
+  __pyx_t_16 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_643stream_SMA, 0, __pyx_mstate_global->__pyx_n_u_stream_SMA, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[347])); if (unlikely(!__pyx_t_16)) __PYX_ERR(5, 4658, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_16);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_16, __pyx_t_19);
+  __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_SMA, __pyx_t_16) < (0)) __PYX_ERR(5, 4658, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
+
+  __pyx_t_16 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_645stream_SQRT, 0, __pyx_mstate_global->__pyx_n_u_stream_SQRT, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[348])); if (unlikely(!__pyx_t_16)) __PYX_ERR(5, 4687, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_16);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_SQRT, __pyx_t_16) < (0)) __PYX_ERR(5, 4687, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
+
+  __pyx_t_16 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_16)) __PYX_ERR(5, 4716, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_16);
+  __pyx_t_19 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 4716, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_19);
+
+  __pyx_t_7 = PyTuple_Pack(2, __pyx_t_16, __pyx_t_19); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 4714, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
+  __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
+  __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_647stream_STDDEV, 0, __pyx_mstate_global->__pyx_n_u_stream_STDDEV, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[349])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 4714, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_19);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_19, __pyx_t_7);
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_STDDEV, __pyx_t_19) < (0)) __PYX_ERR(5, 4714, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
+
+  __pyx_t_19 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 4746, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_19);
+  __pyx_t_7 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 4746, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __pyx_t_16 = __Pyx_PyLong_From_int(((int)0)); if (unlikely(!__pyx_t_16)) __PYX_ERR(5, 4746, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_16);
+  __pyx_t_15 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_15)) __PYX_ERR(5, 4746, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_15);
+  __pyx_t_20 = __Pyx_PyLong_From_int(((int)0)); if (unlikely(!__pyx_t_20)) __PYX_ERR(5, 4746, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_20);
+
+  __pyx_t_3 = PyTuple_Pack(5, __pyx_t_19, __pyx_t_7, __pyx_t_16, __pyx_t_15, __pyx_t_20); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 4744, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
+  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
+  __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+  __pyx_t_20 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_649stream_STOCH, 0, __pyx_mstate_global->__pyx_n_u_stream_STOCH, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[350])); if (unlikely(!__pyx_t_20)) __PYX_ERR(5, 4744, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_20);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_20, __pyx_t_3);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_STOCH, __pyx_t_20) < (0)) __PYX_ERR(5, 4744, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+
+  __pyx_t_20 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_20)) __PYX_ERR(5, 4788, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_20);
+  __pyx_t_3 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 4788, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_15 = __Pyx_PyLong_From_int(((int)0)); if (unlikely(!__pyx_t_15)) __PYX_ERR(5, 4788, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_15);
+
+  __pyx_t_16 = PyTuple_Pack(3, __pyx_t_20, __pyx_t_3, __pyx_t_15); if (unlikely(!__pyx_t_16)) __PYX_ERR(5, 4786, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_16);
+  __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
+  __pyx_t_15 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_651stream_STOCHF, 0, __pyx_mstate_global->__pyx_n_u_stream_STOCHF, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[351])); if (unlikely(!__pyx_t_15)) __PYX_ERR(5, 4786, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_15);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_15, __pyx_t_16);
+  __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_STOCHF, __pyx_t_15) < (0)) __PYX_ERR(5, 4786, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
+
+  __pyx_t_15 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_15)) __PYX_ERR(5, 4828, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_15);
+  __pyx_t_16 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_16)) __PYX_ERR(5, 4828, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_16);
+  __pyx_t_3 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 4828, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_20 = __Pyx_PyLong_From_int(((int)0)); if (unlikely(!__pyx_t_20)) __PYX_ERR(5, 4828, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_20);
+
+  __pyx_t_7 = PyTuple_Pack(4, __pyx_t_15, __pyx_t_16, __pyx_t_3, __pyx_t_20); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 4826, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
+  __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+  __pyx_t_20 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_653stream_STOCHRSI, 0, __pyx_mstate_global->__pyx_n_u_stream_STOCHRSI, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[352])); if (unlikely(!__pyx_t_20)) __PYX_ERR(5, 4826, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_20);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_20, __pyx_t_7);
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_STOCHRSI, __pyx_t_20) < (0)) __PYX_ERR(5, 4826, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+
+  __pyx_t_20 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_655stream_SUB, 0, __pyx_mstate_global->__pyx_n_u_stream_SUB, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[353])); if (unlikely(!__pyx_t_20)) __PYX_ERR(5, 4861, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_20);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_SUB, __pyx_t_20) < (0)) __PYX_ERR(5, 4861, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+
+  __pyx_t_20 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_20)) __PYX_ERR(5, 4894, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_20);
+
+  __pyx_t_7 = PyTuple_Pack(1, __pyx_t_20); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 4892, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+  __pyx_t_20 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_657stream_SUM, 0, __pyx_mstate_global->__pyx_n_u_stream_SUM, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[354])); if (unlikely(!__pyx_t_20)) __PYX_ERR(5, 4892, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_20);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_20, __pyx_t_7);
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_SUM, __pyx_t_20) < (0)) __PYX_ERR(5, 4892, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+
+  __pyx_t_20 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_20)) __PYX_ERR(5, 4923, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_20);
+  __pyx_t_7 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 4923, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+
+  __pyx_t_3 = PyTuple_Pack(2, __pyx_t_20, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 4921, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_659stream_T3, 0, __pyx_mstate_global->__pyx_n_u_stream_T3, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[355])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 4921, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_7, __pyx_t_3);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_T3, __pyx_t_7) < (0)) __PYX_ERR(5, 4921, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_661stream_TAN, 0, __pyx_mstate_global->__pyx_n_u_stream_TAN, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[356])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 4951, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_TAN, __pyx_t_7) < (0)) __PYX_ERR(5, 4951, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_663stream_TANH, 0, __pyx_mstate_global->__pyx_n_u_stream_TANH, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[357])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 4978, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_TANH, __pyx_t_7) < (0)) __PYX_ERR(5, 4978, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 5007, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+
+  __pyx_t_3 = PyTuple_Pack(1, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 5005, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_665stream_TEMA, 0, __pyx_mstate_global->__pyx_n_u_stream_TEMA, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[358])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 5005, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_7, __pyx_t_3);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_TEMA, __pyx_t_7) < (0)) __PYX_ERR(5, 5005, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_667stream_TRANGE, 0, __pyx_mstate_global->__pyx_n_u_stream_TRANGE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[359])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 5034, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_TRANGE, __pyx_t_7) < (0)) __PYX_ERR(5, 5034, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 5069, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+
+  __pyx_t_3 = PyTuple_Pack(1, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 5067, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_669stream_TRIMA, 0, __pyx_mstate_global->__pyx_n_u_stream_TRIMA, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[360])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 5067, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_7, __pyx_t_3);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_TRIMA, __pyx_t_7) < (0)) __PYX_ERR(5, 5067, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 5098, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+
+  __pyx_t_3 = PyTuple_Pack(1, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 5096, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_671stream_TRIX, 0, __pyx_mstate_global->__pyx_n_u_stream_TRIX, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[361])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 5096, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_7, __pyx_t_3);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_TRIX, __pyx_t_7) < (0)) __PYX_ERR(5, 5096, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 5127, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+
+  __pyx_t_3 = PyTuple_Pack(1, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 5125, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_673stream_TSF, 0, __pyx_mstate_global->__pyx_n_u_stream_TSF, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[362])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 5125, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_7, __pyx_t_3);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_TSF, __pyx_t_7) < (0)) __PYX_ERR(5, 5125, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_675stream_TYPPRICE, 0, __pyx_mstate_global->__pyx_n_u_stream_TYPPRICE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[363])); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 5154, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_TYPPRICE, __pyx_t_7) < (0)) __PYX_ERR(5, 5154, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_7)) __PYX_ERR(5, 5189, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __pyx_t_3 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 5189, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_20 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_20)) __PYX_ERR(5, 5189, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_20);
+
+  __pyx_t_16 = PyTuple_Pack(3, __pyx_t_7, __pyx_t_3, __pyx_t_20); if (unlikely(!__pyx_t_16)) __PYX_ERR(5, 5187, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_16);
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+  __pyx_t_20 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_677stream_ULTOSC, 0, __pyx_mstate_global->__pyx_n_u_stream_ULTOSC, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[364])); if (unlikely(!__pyx_t_20)) __PYX_ERR(5, 5187, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_20);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_20, __pyx_t_16);
+  __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_ULTOSC, __pyx_t_20) < (0)) __PYX_ERR(5, 5187, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+
+  __pyx_t_20 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_20)) __PYX_ERR(5, 5226, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_20);
+  __pyx_t_16 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_16)) __PYX_ERR(5, 5226, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_16);
+
+  __pyx_t_3 = PyTuple_Pack(2, __pyx_t_20, __pyx_t_16); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 5224, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+  __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
+  __pyx_t_16 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_679stream_VAR, 0, __pyx_mstate_global->__pyx_n_u_stream_VAR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[365])); if (unlikely(!__pyx_t_16)) __PYX_ERR(5, 5224, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_16);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_16, __pyx_t_3);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_VAR, __pyx_t_16) < (0)) __PYX_ERR(5, 5224, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
+
+  __pyx_t_16 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_681stream_WCLPRICE, 0, __pyx_mstate_global->__pyx_n_u_stream_WCLPRICE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[366])); if (unlikely(!__pyx_t_16)) __PYX_ERR(5, 5254, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_16);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_WCLPRICE, __pyx_t_16) < (0)) __PYX_ERR(5, 5254, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
+
+  __pyx_t_16 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_16)) __PYX_ERR(5, 5289, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_16);
+
+  __pyx_t_3 = PyTuple_Pack(1, __pyx_t_16); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 5287, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
+  __pyx_t_16 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_683stream_WILLR, 0, __pyx_mstate_global->__pyx_n_u_stream_WILLR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[367])); if (unlikely(!__pyx_t_16)) __PYX_ERR(5, 5287, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_16);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_16, __pyx_t_3);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_WILLR, __pyx_t_16) < (0)) __PYX_ERR(5, 5287, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
+
+  __pyx_t_16 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_16)) __PYX_ERR(5, 5324, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_16);
+
+  __pyx_t_3 = PyTuple_Pack(1, __pyx_t_16); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 5322, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
+  __pyx_t_16 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_685stream_WMA, 0, __pyx_mstate_global->__pyx_n_u_stream_WMA, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[368])); if (unlikely(!__pyx_t_16)) __PYX_ERR(5, 5322, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_16);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_16, __pyx_t_3);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_WMA, __pyx_t_16) < (0)) __PYX_ERR(5, 5322, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
+
+  __Pyx_GetModuleGlobalName(__pyx_t_16, __pyx_mstate_global->__pyx_n_u_TA_FUNCTION_NAMES); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 8, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_16);
+  __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 8, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_GetModuleGlobalName(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_TA_FUNCTION_NAMES); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 8, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_20);
+  if (likely(PyList_CheckExact(__pyx_t_20)) || PyTuple_CheckExact(__pyx_t_20)) {
+    __pyx_t_7 = __pyx_t_20; __Pyx_INCREF(__pyx_t_7);
+    __pyx_t_18 = 0;
+    __pyx_t_33 = NULL;
+  } else {
+    __pyx_t_18 = -1; __pyx_t_7 = PyObject_GetIter(__pyx_t_20); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 8, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    __pyx_t_33 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_7); if (unlikely(!__pyx_t_33)) __PYX_ERR(0, 8, __pyx_L1_error)
+  }
+  __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+  for (;;) {
+    if (likely(!__pyx_t_33)) {
+      if (likely(PyList_CheckExact(__pyx_t_7))) {
+        {
+          Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_7);
+          #if !CYTHON_ASSUME_SAFE_SIZE
+          if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 8, __pyx_L1_error)
+          #endif
+          if (__pyx_t_18 >= __pyx_temp) break;
+        }
+        __pyx_t_20 = __Pyx_PyList_GetItemRef(__pyx_t_7, __pyx_t_18);
+        ++__pyx_t_18;
+      } else {
+        {
+          Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_7);
+          #if !CYTHON_ASSUME_SAFE_SIZE
+          if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 8, __pyx_L1_error)
+          #endif
+          if (__pyx_t_18 >= __pyx_temp) break;
+        }
+        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+        __pyx_t_20 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_7, __pyx_t_18));
+        #else
+        __pyx_t_20 = __Pyx_PySequence_ITEM(__pyx_t_7, __pyx_t_18);
+        #endif
+        ++__pyx_t_18;
+      }
+      if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 8, __pyx_L1_error)
+    } else {
+      __pyx_t_20 = __pyx_t_33(__pyx_t_7);
+      if (unlikely(!__pyx_t_20)) {
+        PyObject* exc_type = PyErr_Occurred();
+        if (exc_type) {
+          if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 8, __pyx_L1_error)
+          PyErr_Clear();
+        }
+        break;
+      }
+    }
+    __Pyx_GOTREF(__pyx_t_20);
+    if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_name, __pyx_t_20) < (0)) __PYX_ERR(0, 8, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+    __Pyx_GetModuleGlobalName(__pyx_t_20, __pyx_mstate_global->__pyx_n_u_name); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 8, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_20);
+    __pyx_t_15 = __Pyx_PyUnicode_FormatSafe(__pyx_mstate_global->__pyx_kp_u_stream__s, __pyx_t_20); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 8, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_15);
+    __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+    if (unlikely(__Pyx_ListComp_Append(__pyx_t_3, (PyObject*)__pyx_t_15))) __PYX_ERR(0, 8, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
+  }
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  __pyx_t_7 = PyNumber_Add(__pyx_t_16, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 8, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_all, __pyx_t_7) < (0)) __PYX_ERR(0, 8, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  __pyx_t_7 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_test, __pyx_t_7) < (0)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+  /*--- Wrapped vars code ---*/
+
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __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_9);
+  __Pyx_XDECREF(__pyx_t_10);
+  __Pyx_XDECREF(__pyx_t_11);
+  __Pyx_XDECREF(__pyx_t_12);
+  __Pyx_XDECREF(__pyx_t_13);
+  __Pyx_XDECREF(__pyx_t_14);
+  __Pyx_XDECREF(__pyx_t_15);
+  __Pyx_XDECREF(__pyx_t_16);
+  __Pyx_XDECREF(__pyx_t_19);
+  __Pyx_XDECREF(__pyx_t_20);
+  __Pyx_XDECREF(__pyx_t_21);
+  if (__pyx_m) {
+    if (__pyx_mstate->__pyx_d && stringtab_initialized) {
+      __Pyx_AddTraceback("init talib._ta_lib", __pyx_clineno, __pyx_lineno, __pyx_filename);
+    }
+    #if !CYTHON_USE_MODULE_STATE
+    Py_CLEAR(__pyx_m);
+    #else
+    Py_DECREF(__pyx_m);
+    if (pystate_addmodule_run) {
+      PyObject *tp, *value, *tb;
+      PyErr_Fetch(&tp, &value, &tb);
+      PyState_RemoveModule(&__pyx_moduledef);
+      PyErr_Restore(tp, value, tb);
+    }
+    #endif
+  } else if (!PyErr_Occurred()) {
+    PyErr_SetString(PyExc_ImportError, "init talib._ta_lib");
+  }
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  #if CYTHON_PEP489_MULTI_PHASE_INIT
+  return (__pyx_m != NULL) ? 0 : -1;
+  #else
+  return __pyx_m;
+  #endif
+}
+/* #### Code section: pystring_table ### */
+
+typedef struct {
+    const char *s;
+#if 1493 <= 65535
+    const unsigned short n;
+#elif 1493 / 2 < INT_MAX
+    const unsigned int n;
+#elif 1493 / 2 < LONG_MAX
+    const unsigned long n;
+#else
+    const Py_ssize_t n;
+#endif
+#if 1 <= 31
+    const unsigned int encoding : 5;
+#elif 1 <= 255
+    const unsigned char encoding;
+#elif 1 <= 65535
+    const unsigned short encoding;
+#else
+    const Py_ssize_t encoding;
+#endif
+    const unsigned int is_unicode : 1;
+    const unsigned int intern : 1;
+} __Pyx_StringTabEntry;
+static const char * const __pyx_string_tab_encodings[] = { 0 };
+static const __Pyx_StringTabEntry __pyx_string_tab[] = {
+  {__pyx_k_, sizeof(__pyx_k_), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_ */
+  {__pyx_k_3, sizeof(__pyx_k_3), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_3 */
+  {__pyx_k_ACCBANDS, sizeof(__pyx_k_ACCBANDS), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ACCBANDS */
+  {__pyx_k_ACOS, sizeof(__pyx_k_ACOS), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ACOS */
+  {__pyx_k_AD, sizeof(__pyx_k_AD), 0, 1, 1}, /* PyObject cname: __pyx_n_u_AD */
+  {__pyx_k_ADD, sizeof(__pyx_k_ADD), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ADD */
+  {__pyx_k_ADOSC, sizeof(__pyx_k_ADOSC), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ADOSC */
+  {__pyx_k_ADX, sizeof(__pyx_k_ADX), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ADX */
+  {__pyx_k_ADXR, sizeof(__pyx_k_ADXR), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ADXR */
+  {__pyx_k_ALL, sizeof(__pyx_k_ALL), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ALL */
+  {__pyx_k_APO, sizeof(__pyx_k_APO), 0, 1, 1}, /* PyObject cname: __pyx_n_u_APO */
+  {__pyx_k_AROON, sizeof(__pyx_k_AROON), 0, 1, 1}, /* PyObject cname: __pyx_n_u_AROON */
+  {__pyx_k_AROONOSC, sizeof(__pyx_k_AROONOSC), 0, 1, 1}, /* PyObject cname: __pyx_n_u_AROONOSC */
+  {__pyx_k_ARRAY_TYPES, sizeof(__pyx_k_ARRAY_TYPES), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ARRAY_TYPES */
+  {__pyx_k_ASIN, sizeof(__pyx_k_ASIN), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ASIN */
+  {__pyx_k_ATAN, sizeof(__pyx_k_ATAN), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ATAN */
+  {__pyx_k_ATR, sizeof(__pyx_k_ATR), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ATR */
+  {__pyx_k_AVGDEV, sizeof(__pyx_k_AVGDEV), 0, 1, 1}, /* PyObject cname: __pyx_n_u_AVGDEV */
+  {__pyx_k_AVGPRICE, sizeof(__pyx_k_AVGPRICE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_AVGPRICE */
+  {__pyx_k_AllCandleSettings, sizeof(__pyx_k_AllCandleSettings), 0, 1, 1}, /* PyObject cname: __pyx_n_u_AllCandleSettings */
+  {__pyx_k_Allocation_Error_TA_ALLOC_ERR, sizeof(__pyx_k_Allocation_Error_TA_ALLOC_ERR), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Allocation_Error_TA_ALLOC_ERR */
+  {__pyx_k_BBANDS, sizeof(__pyx_k_BBANDS), 0, 1, 1}, /* PyObject cname: __pyx_n_u_BBANDS */
+  {__pyx_k_BETA, sizeof(__pyx_k_BETA), 0, 1, 1}, /* PyObject cname: __pyx_n_u_BETA */
+  {__pyx_k_BOP, sizeof(__pyx_k_BOP), 0, 1, 1}, /* PyObject cname: __pyx_n_u_BOP */
+  {__pyx_k_Bad_Object_TA_BAD_OBJECT, sizeof(__pyx_k_Bad_Object_TA_BAD_OBJECT), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Bad_Object_TA_BAD_OBJECT */
+  {__pyx_k_Bad_Parameter_TA_BAD_PARAM, sizeof(__pyx_k_Bad_Parameter_TA_BAD_PARAM), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Bad_Parameter_TA_BAD_PARAM */
+  {__pyx_k_BodyDoji, sizeof(__pyx_k_BodyDoji), 0, 1, 1}, /* PyObject cname: __pyx_n_u_BodyDoji */
+  {__pyx_k_BodyLong, sizeof(__pyx_k_BodyLong), 0, 1, 1}, /* PyObject cname: __pyx_n_u_BodyLong */
+  {__pyx_k_BodyShort, sizeof(__pyx_k_BodyShort), 0, 1, 1}, /* PyObject cname: __pyx_n_u_BodyShort */
+  {__pyx_k_BodyVeryLong, sizeof(__pyx_k_BodyVeryLong), 0, 1, 1}, /* PyObject cname: __pyx_n_u_BodyVeryLong */
+  {__pyx_k_Bull_Bear_Pattern_Bearish_0_Neut, sizeof(__pyx_k_Bull_Bear_Pattern_Bearish_0_Neut), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Bull_Bear_Pattern_Bearish_0_Neut */
+  {__pyx_k_CCI, sizeof(__pyx_k_CCI), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CCI */
+  {__pyx_k_CDL2CROWS, sizeof(__pyx_k_CDL2CROWS), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDL2CROWS */
+  {__pyx_k_CDL3BLACKCROWS, sizeof(__pyx_k_CDL3BLACKCROWS), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDL3BLACKCROWS */
+  {__pyx_k_CDL3INSIDE, sizeof(__pyx_k_CDL3INSIDE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDL3INSIDE */
+  {__pyx_k_CDL3LINESTRIKE, sizeof(__pyx_k_CDL3LINESTRIKE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDL3LINESTRIKE */
+  {__pyx_k_CDL3OUTSIDE, sizeof(__pyx_k_CDL3OUTSIDE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDL3OUTSIDE */
+  {__pyx_k_CDL3STARSINSOUTH, sizeof(__pyx_k_CDL3STARSINSOUTH), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDL3STARSINSOUTH */
+  {__pyx_k_CDL3WHITESOLDIERS, sizeof(__pyx_k_CDL3WHITESOLDIERS), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDL3WHITESOLDIERS */
+  {__pyx_k_CDLABANDONEDBABY, sizeof(__pyx_k_CDLABANDONEDBABY), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLABANDONEDBABY */
+  {__pyx_k_CDLADVANCEBLOCK, sizeof(__pyx_k_CDLADVANCEBLOCK), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLADVANCEBLOCK */
+  {__pyx_k_CDLBELTHOLD, sizeof(__pyx_k_CDLBELTHOLD), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLBELTHOLD */
+  {__pyx_k_CDLBREAKAWAY, sizeof(__pyx_k_CDLBREAKAWAY), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLBREAKAWAY */
+  {__pyx_k_CDLCLOSINGMARUBOZU, sizeof(__pyx_k_CDLCLOSINGMARUBOZU), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLCLOSINGMARUBOZU */
+  {__pyx_k_CDLCONCEALBABYSWALL, sizeof(__pyx_k_CDLCONCEALBABYSWALL), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLCONCEALBABYSWALL */
+  {__pyx_k_CDLCOUNTERATTACK, sizeof(__pyx_k_CDLCOUNTERATTACK), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLCOUNTERATTACK */
+  {__pyx_k_CDLDARKCLOUDCOVER, sizeof(__pyx_k_CDLDARKCLOUDCOVER), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLDARKCLOUDCOVER */
+  {__pyx_k_CDLDOJI, sizeof(__pyx_k_CDLDOJI), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLDOJI */
+  {__pyx_k_CDLDOJISTAR, sizeof(__pyx_k_CDLDOJISTAR), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLDOJISTAR */
+  {__pyx_k_CDLDRAGONFLYDOJI, sizeof(__pyx_k_CDLDRAGONFLYDOJI), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLDRAGONFLYDOJI */
+  {__pyx_k_CDLENGULFING, sizeof(__pyx_k_CDLENGULFING), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLENGULFING */
+  {__pyx_k_CDLEVENINGDOJISTAR, sizeof(__pyx_k_CDLEVENINGDOJISTAR), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLEVENINGDOJISTAR */
+  {__pyx_k_CDLEVENINGSTAR, sizeof(__pyx_k_CDLEVENINGSTAR), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLEVENINGSTAR */
+  {__pyx_k_CDLGAPSIDESIDEWHITE, sizeof(__pyx_k_CDLGAPSIDESIDEWHITE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLGAPSIDESIDEWHITE */
+  {__pyx_k_CDLGRAVESTONEDOJI, sizeof(__pyx_k_CDLGRAVESTONEDOJI), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLGRAVESTONEDOJI */
+  {__pyx_k_CDLHAMMER, sizeof(__pyx_k_CDLHAMMER), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLHAMMER */
+  {__pyx_k_CDLHANGINGMAN, sizeof(__pyx_k_CDLHANGINGMAN), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLHANGINGMAN */
+  {__pyx_k_CDLHARAMI, sizeof(__pyx_k_CDLHARAMI), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLHARAMI */
+  {__pyx_k_CDLHARAMICROSS, sizeof(__pyx_k_CDLHARAMICROSS), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLHARAMICROSS */
+  {__pyx_k_CDLHIGHWAVE, sizeof(__pyx_k_CDLHIGHWAVE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLHIGHWAVE */
+  {__pyx_k_CDLHIKKAKE, sizeof(__pyx_k_CDLHIKKAKE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLHIKKAKE */
+  {__pyx_k_CDLHIKKAKEMOD, sizeof(__pyx_k_CDLHIKKAKEMOD), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLHIKKAKEMOD */
+  {__pyx_k_CDLHOMINGPIGEON, sizeof(__pyx_k_CDLHOMINGPIGEON), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLHOMINGPIGEON */
+  {__pyx_k_CDLIDENTICAL3CROWS, sizeof(__pyx_k_CDLIDENTICAL3CROWS), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLIDENTICAL3CROWS */
+  {__pyx_k_CDLINNECK, sizeof(__pyx_k_CDLINNECK), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLINNECK */
+  {__pyx_k_CDLINVERTEDHAMMER, sizeof(__pyx_k_CDLINVERTEDHAMMER), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLINVERTEDHAMMER */
+  {__pyx_k_CDLKICKING, sizeof(__pyx_k_CDLKICKING), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLKICKING */
+  {__pyx_k_CDLKICKINGBYLENGTH, sizeof(__pyx_k_CDLKICKINGBYLENGTH), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLKICKINGBYLENGTH */
+  {__pyx_k_CDLLADDERBOTTOM, sizeof(__pyx_k_CDLLADDERBOTTOM), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLLADDERBOTTOM */
+  {__pyx_k_CDLLONGLEGGEDDOJI, sizeof(__pyx_k_CDLLONGLEGGEDDOJI), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLLONGLEGGEDDOJI */
+  {__pyx_k_CDLLONGLINE, sizeof(__pyx_k_CDLLONGLINE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLLONGLINE */
+  {__pyx_k_CDLMARUBOZU, sizeof(__pyx_k_CDLMARUBOZU), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLMARUBOZU */
+  {__pyx_k_CDLMATCHINGLOW, sizeof(__pyx_k_CDLMATCHINGLOW), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLMATCHINGLOW */
+  {__pyx_k_CDLMATHOLD, sizeof(__pyx_k_CDLMATHOLD), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLMATHOLD */
+  {__pyx_k_CDLMORNINGDOJISTAR, sizeof(__pyx_k_CDLMORNINGDOJISTAR), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLMORNINGDOJISTAR */
+  {__pyx_k_CDLMORNINGSTAR, sizeof(__pyx_k_CDLMORNINGSTAR), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLMORNINGSTAR */
+  {__pyx_k_CDLONNECK, sizeof(__pyx_k_CDLONNECK), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLONNECK */
+  {__pyx_k_CDLPIERCING, sizeof(__pyx_k_CDLPIERCING), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLPIERCING */
+  {__pyx_k_CDLRICKSHAWMAN, sizeof(__pyx_k_CDLRICKSHAWMAN), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLRICKSHAWMAN */
+  {__pyx_k_CDLRISEFALL3METHODS, sizeof(__pyx_k_CDLRISEFALL3METHODS), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLRISEFALL3METHODS */
+  {__pyx_k_CDLSEPARATINGLINES, sizeof(__pyx_k_CDLSEPARATINGLINES), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLSEPARATINGLINES */
+  {__pyx_k_CDLSHOOTINGSTAR, sizeof(__pyx_k_CDLSHOOTINGSTAR), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLSHOOTINGSTAR */
+  {__pyx_k_CDLSHORTLINE, sizeof(__pyx_k_CDLSHORTLINE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLSHORTLINE */
+  {__pyx_k_CDLSPINNINGTOP, sizeof(__pyx_k_CDLSPINNINGTOP), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLSPINNINGTOP */
+  {__pyx_k_CDLSTALLEDPATTERN, sizeof(__pyx_k_CDLSTALLEDPATTERN), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLSTALLEDPATTERN */
+  {__pyx_k_CDLSTICKSANDWICH, sizeof(__pyx_k_CDLSTICKSANDWICH), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLSTICKSANDWICH */
+  {__pyx_k_CDLTAKURI, sizeof(__pyx_k_CDLTAKURI), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLTAKURI */
+  {__pyx_k_CDLTASUKIGAP, sizeof(__pyx_k_CDLTASUKIGAP), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLTASUKIGAP */
+  {__pyx_k_CDLTHRUSTING, sizeof(__pyx_k_CDLTHRUSTING), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLTHRUSTING */
+  {__pyx_k_CDLTRISTAR, sizeof(__pyx_k_CDLTRISTAR), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLTRISTAR */
+  {__pyx_k_CDLUNIQUE3RIVER, sizeof(__pyx_k_CDLUNIQUE3RIVER), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLUNIQUE3RIVER */
+  {__pyx_k_CDLUPSIDEGAP2CROWS, sizeof(__pyx_k_CDLUPSIDEGAP2CROWS), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLUPSIDEGAP2CROWS */
+  {__pyx_k_CDLXSIDEGAP3METHODS, sizeof(__pyx_k_CDLXSIDEGAP3METHODS), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CDLXSIDEGAP3METHODS */
+  {__pyx_k_CEIL, sizeof(__pyx_k_CEIL), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CEIL */
+  {__pyx_k_CMO, sizeof(__pyx_k_CMO), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CMO */
+  {__pyx_k_CORREL, sizeof(__pyx_k_CORREL), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CORREL */
+  {__pyx_k_COS, sizeof(__pyx_k_COS), 0, 1, 1}, /* PyObject cname: __pyx_n_u_COS */
+  {__pyx_k_COSH, sizeof(__pyx_k_COSH), 0, 1, 1}, /* PyObject cname: __pyx_n_u_COSH */
+  {__pyx_k_CandleSettingType, sizeof(__pyx_k_CandleSettingType), 0, 1, 1}, /* PyObject cname: __pyx_n_u_CandleSettingType */
+  {__pyx_k_DEMA, sizeof(__pyx_k_DEMA), 0, 1, 1}, /* PyObject cname: __pyx_n_u_DEMA */
+  {__pyx_k_DIV, sizeof(__pyx_k_DIV), 0, 1, 1}, /* PyObject cname: __pyx_n_u_DIV */
+  {__pyx_k_DX, sizeof(__pyx_k_DX), 0, 1, 1}, /* PyObject cname: __pyx_n_u_DX */
+  {__pyx_k_Dashed_Line, sizeof(__pyx_k_Dashed_Line), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Dashed_Line */
+  {__pyx_k_DataFrame, sizeof(__pyx_k_DataFrame), 0, 1, 1}, /* PyObject cname: __pyx_n_u_DataFrame */
+  {__pyx_k_Dot, sizeof(__pyx_k_Dot), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Dot */
+  {__pyx_k_Dotted_Line, sizeof(__pyx_k_Dotted_Line), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Dotted_Line */
+  {__pyx_k_Double_Exponential_Moving_Averag, sizeof(__pyx_k_Double_Exponential_Moving_Averag), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Double_Exponential_Moving_Averag */
+  {__pyx_k_EMA, sizeof(__pyx_k_EMA), 0, 1, 1}, /* PyObject cname: __pyx_n_u_EMA */
+  {__pyx_k_EXP, sizeof(__pyx_k_EXP), 0, 1, 1}, /* PyObject cname: __pyx_n_u_EXP */
+  {__pyx_k_Equal, sizeof(__pyx_k_Equal), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Equal */
+  {__pyx_k_Exponential_Moving_Average, sizeof(__pyx_k_Exponential_Moving_Average), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Exponential_Moving_Average */
+  {__pyx_k_FLOOR, sizeof(__pyx_k_FLOOR), 0, 1, 1}, /* PyObject cname: __pyx_n_u_FLOOR */
+  {__pyx_k_Far, sizeof(__pyx_k_Far), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Far */
+  {__pyx_k_Function, sizeof(__pyx_k_Function), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Function */
+  {__pyx_k_Function_Not_Found_TA_FUNC_NOT_F, sizeof(__pyx_k_Function_Not_Found_TA_FUNC_NOT_F), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Function_Not_Found_TA_FUNC_NOT_F */
+  {__pyx_k_Function___call, sizeof(__pyx_k_Function___call), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Function___call */
+  {__pyx_k_Function___call_function, sizeof(__pyx_k_Function___call_function), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Function___call_function */
+  {__pyx_k_Function___check_opt_input_value, sizeof(__pyx_k_Function___check_opt_input_value), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Function___check_opt_input_value */
+  {__pyx_k_Function___get_opt_input_value, sizeof(__pyx_k_Function___get_opt_input_value), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Function___get_opt_input_value */
+  {__pyx_k_Function___init, sizeof(__pyx_k_Function___init), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Function___init */
+  {__pyx_k_Function___input_price_series_na, sizeof(__pyx_k_Function___input_price_series_na), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Function___input_price_series_na */
+  {__pyx_k_Function___local, sizeof(__pyx_k_Function___local), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Function___local */
+  {__pyx_k_Function___repr, sizeof(__pyx_k_Function___repr), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Function___repr */
+  {__pyx_k_Function___str, sizeof(__pyx_k_Function___str), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Function___str */
+  {__pyx_k_Function___unicode, sizeof(__pyx_k_Function___unicode), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Function___unicode */
+  {__pyx_k_Function__call_function, sizeof(__pyx_k_Function__call_function), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Function__call_function */
+  {__pyx_k_Function__check_opt_input_value, sizeof(__pyx_k_Function__check_opt_input_value), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Function__check_opt_input_value */
+  {__pyx_k_Function__get_opt_input_value, sizeof(__pyx_k_Function__get_opt_input_value), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Function__get_opt_input_value */
+  {__pyx_k_Function__input_price_series_na, sizeof(__pyx_k_Function__input_price_series_na), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Function__input_price_series_na */
+  {__pyx_k_Function__local, sizeof(__pyx_k_Function__local), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Function__local */
+  {__pyx_k_Function__localdata, sizeof(__pyx_k_Function__localdata), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Function__localdata */
+  {__pyx_k_Function__name, sizeof(__pyx_k_Function__name), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Function__name */
+  {__pyx_k_Function__namestr, sizeof(__pyx_k_Function__namestr), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Function__namestr */
+  {__pyx_k_Function_function_flags, sizeof(__pyx_k_Function_function_flags), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Function_function_flags */
+  {__pyx_k_Function_get_input_arrays, sizeof(__pyx_k_Function_get_input_arrays), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Function_get_input_arrays */
+  {__pyx_k_Function_get_input_names, sizeof(__pyx_k_Function_get_input_names), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Function_get_input_names */
+  {__pyx_k_Function_get_parameters, sizeof(__pyx_k_Function_get_parameters), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Function_get_parameters */
+  {__pyx_k_Function_has_an_unstable_period, sizeof(__pyx_k_Function_has_an_unstable_period), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Function_has_an_unstable_period */
+  {__pyx_k_Function_info, sizeof(__pyx_k_Function_info), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Function_info */
+  {__pyx_k_Function_lookback, sizeof(__pyx_k_Function_lookback), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Function_lookback */
+  {__pyx_k_Function_output_flags, sizeof(__pyx_k_Function_output_flags), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Function_output_flags */
+  {__pyx_k_Function_output_names, sizeof(__pyx_k_Function_output_names), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Function_output_names */
+  {__pyx_k_Function_outputs, sizeof(__pyx_k_Function_outputs), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Function_outputs */
+  {__pyx_k_Function_run, sizeof(__pyx_k_Function_run), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Function_run */
+  {__pyx_k_Function_set_function_args, sizeof(__pyx_k_Function_set_function_args), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Function_set_function_args */
+  {__pyx_k_Function_set_input_arrays, sizeof(__pyx_k_Function_set_input_arrays), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Function_set_input_arrays */
+  {__pyx_k_Function_set_input_names, sizeof(__pyx_k_Function_set_input_names), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Function_set_input_names */
+  {__pyx_k_Function_set_parameters, sizeof(__pyx_k_Function_set_parameters), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Function_set_parameters */
+  {__pyx_k_Group_Not_Found_TA_GROUP_NOT_FOU, sizeof(__pyx_k_Group_Not_Found_TA_GROUP_NOT_FOU), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Group_Not_Found_TA_GROUP_NOT_FOU */
+  {__pyx_k_HT_DCPERIOD, sizeof(__pyx_k_HT_DCPERIOD), 0, 1, 1}, /* PyObject cname: __pyx_n_u_HT_DCPERIOD */
+  {__pyx_k_HT_DCPHASE, sizeof(__pyx_k_HT_DCPHASE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_HT_DCPHASE */
+  {__pyx_k_HT_PHASOR, sizeof(__pyx_k_HT_PHASOR), 0, 1, 1}, /* PyObject cname: __pyx_n_u_HT_PHASOR */
+  {__pyx_k_HT_SINE, sizeof(__pyx_k_HT_SINE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_HT_SINE */
+  {__pyx_k_HT_TRENDLINE, sizeof(__pyx_k_HT_TRENDLINE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_HT_TRENDLINE */
+  {__pyx_k_HT_TRENDMODE, sizeof(__pyx_k_HT_TRENDMODE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_HT_TRENDMODE */
+  {__pyx_k_HighLow, sizeof(__pyx_k_HighLow), 0, 1, 1}, /* PyObject cname: __pyx_n_u_HighLow */
+  {__pyx_k_Histogram, sizeof(__pyx_k_Histogram), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Histogram */
+  {__pyx_k_IMI, sizeof(__pyx_k_IMI), 0, 1, 1}, /* PyObject cname: __pyx_n_u_IMI */
+  {__pyx_k_INPUT_ARRAYS_TYPES, sizeof(__pyx_k_INPUT_ARRAYS_TYPES), 0, 1, 1}, /* PyObject cname: __pyx_n_u_INPUT_ARRAYS_TYPES */
+  {__pyx_k_INPUT_PRICE_SERIES_DEFAULTS, sizeof(__pyx_k_INPUT_PRICE_SERIES_DEFAULTS), 0, 1, 1}, /* PyObject cname: __pyx_n_u_INPUT_PRICE_SERIES_DEFAULTS */
+  {__pyx_k_ImportError, sizeof(__pyx_k_ImportError), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ImportError */
+  {__pyx_k_IndexError, sizeof(__pyx_k_IndexError), 0, 1, 1}, /* PyObject cname: __pyx_n_u_IndexError */
+  {__pyx_k_Input_Not_All_Initialized_TA_INP, sizeof(__pyx_k_Input_Not_All_Initialized_TA_INP), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Input_Not_All_Initialized_TA_INP */
+  {__pyx_k_Inputs, sizeof(__pyx_k_Inputs), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Inputs */
+  {__pyx_k_Internal_Error_TA_INTERNAL_ERROR, sizeof(__pyx_k_Internal_Error_TA_INTERNAL_ERROR), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Internal_Error_TA_INTERNAL_ERROR */
+  {__pyx_k_Invalid_Handle_TA_INVALID_HANDLE, sizeof(__pyx_k_Invalid_Handle_TA_INVALID_HANDLE), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Invalid_Handle_TA_INVALID_HANDLE */
+  {__pyx_k_Invalid_List_Type_TA_INVALID_LIS, sizeof(__pyx_k_Invalid_List_Type_TA_INVALID_LIS), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Invalid_List_Type_TA_INVALID_LIS */
+  {__pyx_k_Invalid_Parameter_Function_TA_IN, sizeof(__pyx_k_Invalid_Parameter_Function_TA_IN), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Invalid_Parameter_Function_TA_IN */
+  {__pyx_k_Invalid_Parameter_Holder_TA_INVA, sizeof(__pyx_k_Invalid_Parameter_Holder_TA_INVA), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Invalid_Parameter_Holder_TA_INVA */
+  {__pyx_k_Invalid_Parameter_Holder_Type_TA, sizeof(__pyx_k_Invalid_Parameter_Holder_Type_TA), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Invalid_Parameter_Holder_Type_TA */
+  {__pyx_k_Invalid_parameter_value_for, sizeof(__pyx_k_Invalid_parameter_value_for), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Invalid_parameter_value_for */
+  {__pyx_k_KAMA, sizeof(__pyx_k_KAMA), 0, 1, 1}, /* PyObject cname: __pyx_n_u_KAMA */
+  {__pyx_k_Kaufman_Adaptive_Moving_Average, sizeof(__pyx_k_Kaufman_Adaptive_Moving_Average), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Kaufman_Adaptive_Moving_Average */
+  {__pyx_k_LINEARREG, sizeof(__pyx_k_LINEARREG), 0, 1, 1}, /* PyObject cname: __pyx_n_u_LINEARREG */
+  {__pyx_k_LINEARREG_ANGLE, sizeof(__pyx_k_LINEARREG_ANGLE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_LINEARREG_ANGLE */
+  {__pyx_k_LINEARREG_INTERCEPT, sizeof(__pyx_k_LINEARREG_INTERCEPT), 0, 1, 1}, /* PyObject cname: __pyx_n_u_LINEARREG_INTERCEPT */
+  {__pyx_k_LINEARREG_SLOPE, sizeof(__pyx_k_LINEARREG_SLOPE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_LINEARREG_SLOPE */
+  {__pyx_k_LN, sizeof(__pyx_k_LN), 0, 1, 1}, /* PyObject cname: __pyx_n_u_LN */
+  {__pyx_k_LOG10, sizeof(__pyx_k_LOG10), 0, 1, 1}, /* PyObject cname: __pyx_n_u_LOG10 */
+  {__pyx_k_Library_Not_Initialized_TA_LIB_N, sizeof(__pyx_k_Library_Not_Initialized_TA_LIB_N), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Library_Not_Initialized_TA_LIB_N */
+  {__pyx_k_Line, sizeof(__pyx_k_Line), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Line */
+  {__pyx_k_MA, sizeof(__pyx_k_MA), 0, 1, 1}, /* PyObject cname: __pyx_n_u_MA */
+  {__pyx_k_MACD, sizeof(__pyx_k_MACD), 0, 1, 1}, /* PyObject cname: __pyx_n_u_MACD */
+  {__pyx_k_MACDEXT, sizeof(__pyx_k_MACDEXT), 0, 1, 1}, /* PyObject cname: __pyx_n_u_MACDEXT */
+  {__pyx_k_MACDFIX, sizeof(__pyx_k_MACDFIX), 0, 1, 1}, /* PyObject cname: __pyx_n_u_MACDFIX */
+  {__pyx_k_MAMA, sizeof(__pyx_k_MAMA), 0, 1, 1}, /* PyObject cname: __pyx_n_u_MAMA */
+  {__pyx_k_MAVP, sizeof(__pyx_k_MAVP), 0, 1, 1}, /* PyObject cname: __pyx_n_u_MAVP */
+  {__pyx_k_MAX, sizeof(__pyx_k_MAX), 0, 1, 1}, /* PyObject cname: __pyx_n_u_MAX */
+  {__pyx_k_MAXINDEX, sizeof(__pyx_k_MAXINDEX), 0, 1, 1}, /* PyObject cname: __pyx_n_u_MAXINDEX */
+  {__pyx_k_MA_Type, sizeof(__pyx_k_MA_Type), 0, 1, 1}, /* PyObject cname: __pyx_n_u_MA_Type */
+  {__pyx_k_MA_Type___getitem, sizeof(__pyx_k_MA_Type___getitem), 0, 1, 1}, /* PyObject cname: __pyx_n_u_MA_Type___getitem */
+  {__pyx_k_MA_Type___init, sizeof(__pyx_k_MA_Type___init), 0, 1, 1}, /* PyObject cname: __pyx_n_u_MA_Type___init */
+  {__pyx_k_MEDPRICE, sizeof(__pyx_k_MEDPRICE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_MEDPRICE */
+  {__pyx_k_MESA_Adaptive_Moving_Average, sizeof(__pyx_k_MESA_Adaptive_Moving_Average), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_MESA_Adaptive_Moving_Average */
+  {__pyx_k_MFI, sizeof(__pyx_k_MFI), 0, 1, 1}, /* PyObject cname: __pyx_n_u_MFI */
+  {__pyx_k_MIDPOINT, sizeof(__pyx_k_MIDPOINT), 0, 1, 1}, /* PyObject cname: __pyx_n_u_MIDPOINT */
+  {__pyx_k_MIDPRICE, sizeof(__pyx_k_MIDPRICE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_MIDPRICE */
+  {__pyx_k_MIN, sizeof(__pyx_k_MIN), 0, 1, 1}, /* PyObject cname: __pyx_n_u_MIN */
+  {__pyx_k_MININDEX, sizeof(__pyx_k_MININDEX), 0, 1, 1}, /* PyObject cname: __pyx_n_u_MININDEX */
+  {__pyx_k_MINMAX, sizeof(__pyx_k_MINMAX), 0, 1, 1}, /* PyObject cname: __pyx_n_u_MINMAX */
+  {__pyx_k_MINMAXINDEX, sizeof(__pyx_k_MINMAXINDEX), 0, 1, 1}, /* PyObject cname: __pyx_n_u_MINMAXINDEX */
+  {__pyx_k_MINUS_DI, sizeof(__pyx_k_MINUS_DI), 0, 1, 1}, /* PyObject cname: __pyx_n_u_MINUS_DI */
+  {__pyx_k_MINUS_DM, sizeof(__pyx_k_MINUS_DM), 0, 1, 1}, /* PyObject cname: __pyx_n_u_MINUS_DM */
+  {__pyx_k_MOM, sizeof(__pyx_k_MOM), 0, 1, 1}, /* PyObject cname: __pyx_n_u_MOM */
+  {__pyx_k_MULT, sizeof(__pyx_k_MULT), 0, 1, 1}, /* PyObject cname: __pyx_n_u_MULT */
+  {__pyx_k_ModuleNotFoundError, sizeof(__pyx_k_ModuleNotFoundError), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ModuleNotFoundError */
+  {__pyx_k_NATR, sizeof(__pyx_k_NATR), 0, 1, 1}, /* PyObject cname: __pyx_n_u_NATR */
+  {__pyx_k_NONE, sizeof(__pyx_k_NONE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_NONE */
+  {__pyx_k_NameError, sizeof(__pyx_k_NameError), 0, 1, 1}, /* PyObject cname: __pyx_n_u_NameError */
+  {__pyx_k_Near, sizeof(__pyx_k_Near), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Near */
+  {__pyx_k_None, sizeof(__pyx_k_None), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_None */
+  {__pyx_k_Not_Supported_TA_NOT_SUPPORTED, sizeof(__pyx_k_Not_Supported_TA_NOT_SUPPORTED), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Not_Supported_TA_NOT_SUPPORTED */
+  {__pyx_k_Not_enough_price_arguments_expec, sizeof(__pyx_k_Not_enough_price_arguments_expec), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Not_enough_price_arguments_expec */
+  {__pyx_k_Note_that_Cython_is_deliberately, sizeof(__pyx_k_Note_that_Cython_is_deliberately), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Note_that_Cython_is_deliberately */
+  {__pyx_k_OBV, sizeof(__pyx_k_OBV), 0, 1, 1}, /* PyObject cname: __pyx_n_u_OBV */
+  {__pyx_k_OrderedDict, sizeof(__pyx_k_OrderedDict), 0, 1, 1}, /* PyObject cname: __pyx_n_u_OrderedDict */
+  {__pyx_k_Out_of_Range_End_Index_TA_OUT_OF, sizeof(__pyx_k_Out_of_Range_End_Index_TA_OUT_OF), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Out_of_Range_End_Index_TA_OUT_OF */
+  {__pyx_k_Out_of_Range_Start_Index_TA_OUT, sizeof(__pyx_k_Out_of_Range_Start_Index_TA_OUT), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Out_of_Range_Start_Index_TA_OUT */
+  {__pyx_k_Output_Not_All_Initialized_TA_OU, sizeof(__pyx_k_Output_Not_All_Initialized_TA_OU), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Output_Not_All_Initialized_TA_OU */
+  {__pyx_k_Output_can_be_negative, sizeof(__pyx_k_Output_can_be_negative), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Output_can_be_negative */
+  {__pyx_k_Output_can_be_positive, sizeof(__pyx_k_Output_can_be_positive), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Output_can_be_positive */
+  {__pyx_k_Output_can_be_zero, sizeof(__pyx_k_Output_can_be_zero), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Output_can_be_zero */
+  {__pyx_k_Output_is_a_candlestick, sizeof(__pyx_k_Output_is_a_candlestick), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Output_is_a_candlestick */
+  {__pyx_k_Output_is_over_volume, sizeof(__pyx_k_Output_is_over_volume), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Output_is_over_volume */
+  {__pyx_k_Output_scale_same_as_input, sizeof(__pyx_k_Output_scale_same_as_input), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Output_scale_same_as_input */
+  {__pyx_k_Outputs, sizeof(__pyx_k_Outputs), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Outputs */
+  {__pyx_k_PANDAS_DATAFRAME, sizeof(__pyx_k_PANDAS_DATAFRAME), 0, 1, 1}, /* PyObject cname: __pyx_n_u_PANDAS_DATAFRAME */
+  {__pyx_k_PANDAS_SERIES, sizeof(__pyx_k_PANDAS_SERIES), 0, 1, 1}, /* PyObject cname: __pyx_n_u_PANDAS_SERIES */
+  {__pyx_k_PLUS_DI, sizeof(__pyx_k_PLUS_DI), 0, 1, 1}, /* PyObject cname: __pyx_n_u_PLUS_DI */
+  {__pyx_k_PLUS_DM, sizeof(__pyx_k_PLUS_DM), 0, 1, 1}, /* PyObject cname: __pyx_n_u_PLUS_DM */
+  {__pyx_k_POLARS_DATAFRAME, sizeof(__pyx_k_POLARS_DATAFRAME), 0, 1, 1}, /* PyObject cname: __pyx_n_u_POLARS_DATAFRAME */
+  {__pyx_k_POLARS_SERIES, sizeof(__pyx_k_POLARS_SERIES), 0, 1, 1}, /* PyObject cname: __pyx_n_u_POLARS_SERIES */
+  {__pyx_k_PPO, sizeof(__pyx_k_PPO), 0, 1, 1}, /* PyObject cname: __pyx_n_u_PPO */
+  {__pyx_k_Parameters, sizeof(__pyx_k_Parameters), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Parameters */
+  {__pyx_k_Pattern_Bool, sizeof(__pyx_k_Pattern_Bool), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Pattern_Bool */
+  {__pyx_k_ROC, sizeof(__pyx_k_ROC), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ROC */
+  {__pyx_k_ROCP, sizeof(__pyx_k_ROCP), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ROCP */
+  {__pyx_k_ROCR, sizeof(__pyx_k_ROCR), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ROCR */
+  {__pyx_k_ROCR100, sizeof(__pyx_k_ROCR100), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ROCR100 */
+  {__pyx_k_RSI, sizeof(__pyx_k_RSI), 0, 1, 1}, /* PyObject cname: __pyx_n_u_RSI */
+  {__pyx_k_RangeType, sizeof(__pyx_k_RangeType), 0, 1, 1}, /* PyObject cname: __pyx_n_u_RangeType */
+  {__pyx_k_RealBody, sizeof(__pyx_k_RealBody), 0, 1, 1}, /* PyObject cname: __pyx_n_u_RealBody */
+  {__pyx_k_SAR, sizeof(__pyx_k_SAR), 0, 1, 1}, /* PyObject cname: __pyx_n_u_SAR */
+  {__pyx_k_SAREXT, sizeof(__pyx_k_SAREXT), 0, 1, 1}, /* PyObject cname: __pyx_n_u_SAREXT */
+  {__pyx_k_SIN, sizeof(__pyx_k_SIN), 0, 1, 1}, /* PyObject cname: __pyx_n_u_SIN */
+  {__pyx_k_SINH, sizeof(__pyx_k_SINH), 0, 1, 1}, /* PyObject cname: __pyx_n_u_SINH */
+  {__pyx_k_SMA, sizeof(__pyx_k_SMA), 0, 1, 1}, /* PyObject cname: __pyx_n_u_SMA */
+  {__pyx_k_SQRT, sizeof(__pyx_k_SQRT), 0, 1, 1}, /* PyObject cname: __pyx_n_u_SQRT */
+  {__pyx_k_STDDEV, sizeof(__pyx_k_STDDEV), 0, 1, 1}, /* PyObject cname: __pyx_n_u_STDDEV */
+  {__pyx_k_STOCH, sizeof(__pyx_k_STOCH), 0, 1, 1}, /* PyObject cname: __pyx_n_u_STOCH */
+  {__pyx_k_STOCHF, sizeof(__pyx_k_STOCHF), 0, 1, 1}, /* PyObject cname: __pyx_n_u_STOCHF */
+  {__pyx_k_STOCHRSI, sizeof(__pyx_k_STOCHRSI), 0, 1, 1}, /* PyObject cname: __pyx_n_u_STOCHRSI */
+  {__pyx_k_SUB, sizeof(__pyx_k_SUB), 0, 1, 1}, /* PyObject cname: __pyx_n_u_SUB */
+  {__pyx_k_SUM, sizeof(__pyx_k_SUM), 0, 1, 1}, /* PyObject cname: __pyx_n_u_SUM */
+  {__pyx_k_Series, sizeof(__pyx_k_Series), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Series */
+  {__pyx_k_ShadowLong, sizeof(__pyx_k_ShadowLong), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ShadowLong */
+  {__pyx_k_ShadowShort, sizeof(__pyx_k_ShadowShort), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ShadowShort */
+  {__pyx_k_ShadowVeryLong, sizeof(__pyx_k_ShadowVeryLong), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ShadowVeryLong */
+  {__pyx_k_ShadowVeryShort, sizeof(__pyx_k_ShadowVeryShort), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ShadowVeryShort */
+  {__pyx_k_Shadows, sizeof(__pyx_k_Shadows), 0, 1, 1}, /* PyObject cname: __pyx_n_u_Shadows */
+  {__pyx_k_Simple_Moving_Average, sizeof(__pyx_k_Simple_Moving_Average), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Simple_Moving_Average */
+  {__pyx_k_Strength_Pattern_200_100_Bearish, sizeof(__pyx_k_Strength_Pattern_200_100_Bearish), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Strength_Pattern_200_100_Bearish */
+  {__pyx_k_T3, sizeof(__pyx_k_T3), 0, 1, 1}, /* PyObject cname: __pyx_n_u_T3 */
+  {__pyx_k_TAN, sizeof(__pyx_k_TAN), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TAN */
+  {__pyx_k_TANH, sizeof(__pyx_k_TANH), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TANH */
+  {__pyx_k_TA_ACCBANDS, sizeof(__pyx_k_TA_ACCBANDS), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_ACCBANDS */
+  {__pyx_k_TA_ACOS, sizeof(__pyx_k_TA_ACOS), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_ACOS */
+  {__pyx_k_TA_AD, sizeof(__pyx_k_TA_AD), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_AD */
+  {__pyx_k_TA_ADD, sizeof(__pyx_k_TA_ADD), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_ADD */
+  {__pyx_k_TA_ADOSC, sizeof(__pyx_k_TA_ADOSC), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_ADOSC */
+  {__pyx_k_TA_ADX, sizeof(__pyx_k_TA_ADX), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_ADX */
+  {__pyx_k_TA_ADXR, sizeof(__pyx_k_TA_ADXR), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_ADXR */
+  {__pyx_k_TA_APO, sizeof(__pyx_k_TA_APO), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_APO */
+  {__pyx_k_TA_AROON, sizeof(__pyx_k_TA_AROON), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_AROON */
+  {__pyx_k_TA_AROONOSC, sizeof(__pyx_k_TA_AROONOSC), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_AROONOSC */
+  {__pyx_k_TA_ASIN, sizeof(__pyx_k_TA_ASIN), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_ASIN */
+  {__pyx_k_TA_ATAN, sizeof(__pyx_k_TA_ATAN), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_ATAN */
+  {__pyx_k_TA_ATR, sizeof(__pyx_k_TA_ATR), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_ATR */
+  {__pyx_k_TA_AVGDEV, sizeof(__pyx_k_TA_AVGDEV), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_AVGDEV */
+  {__pyx_k_TA_AVGPRICE, sizeof(__pyx_k_TA_AVGPRICE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_AVGPRICE */
+  {__pyx_k_TA_BBANDS, sizeof(__pyx_k_TA_BBANDS), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_BBANDS */
+  {__pyx_k_TA_BETA, sizeof(__pyx_k_TA_BETA), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_BETA */
+  {__pyx_k_TA_BOP, sizeof(__pyx_k_TA_BOP), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_BOP */
+  {__pyx_k_TA_CCI, sizeof(__pyx_k_TA_CCI), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CCI */
+  {__pyx_k_TA_CDL2CROWS, sizeof(__pyx_k_TA_CDL2CROWS), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDL2CROWS */
+  {__pyx_k_TA_CDL3BLACKCROWS, sizeof(__pyx_k_TA_CDL3BLACKCROWS), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDL3BLACKCROWS */
+  {__pyx_k_TA_CDL3INSIDE, sizeof(__pyx_k_TA_CDL3INSIDE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDL3INSIDE */
+  {__pyx_k_TA_CDL3LINESTRIKE, sizeof(__pyx_k_TA_CDL3LINESTRIKE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDL3LINESTRIKE */
+  {__pyx_k_TA_CDL3OUTSIDE, sizeof(__pyx_k_TA_CDL3OUTSIDE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDL3OUTSIDE */
+  {__pyx_k_TA_CDL3STARSINSOUTH, sizeof(__pyx_k_TA_CDL3STARSINSOUTH), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDL3STARSINSOUTH */
+  {__pyx_k_TA_CDL3WHITESOLDIERS, sizeof(__pyx_k_TA_CDL3WHITESOLDIERS), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDL3WHITESOLDIERS */
+  {__pyx_k_TA_CDLABANDONEDBABY, sizeof(__pyx_k_TA_CDLABANDONEDBABY), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLABANDONEDBABY */
+  {__pyx_k_TA_CDLADVANCEBLOCK, sizeof(__pyx_k_TA_CDLADVANCEBLOCK), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLADVANCEBLOCK */
+  {__pyx_k_TA_CDLBELTHOLD, sizeof(__pyx_k_TA_CDLBELTHOLD), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLBELTHOLD */
+  {__pyx_k_TA_CDLBREAKAWAY, sizeof(__pyx_k_TA_CDLBREAKAWAY), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLBREAKAWAY */
+  {__pyx_k_TA_CDLCLOSINGMARUBOZU, sizeof(__pyx_k_TA_CDLCLOSINGMARUBOZU), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLCLOSINGMARUBOZU */
+  {__pyx_k_TA_CDLCONCEALBABYSWALL, sizeof(__pyx_k_TA_CDLCONCEALBABYSWALL), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLCONCEALBABYSWALL */
+  {__pyx_k_TA_CDLCOUNTERATTACK, sizeof(__pyx_k_TA_CDLCOUNTERATTACK), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLCOUNTERATTACK */
+  {__pyx_k_TA_CDLDARKCLOUDCOVER, sizeof(__pyx_k_TA_CDLDARKCLOUDCOVER), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLDARKCLOUDCOVER */
+  {__pyx_k_TA_CDLDOJI, sizeof(__pyx_k_TA_CDLDOJI), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLDOJI */
+  {__pyx_k_TA_CDLDOJISTAR, sizeof(__pyx_k_TA_CDLDOJISTAR), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLDOJISTAR */
+  {__pyx_k_TA_CDLDRAGONFLYDOJI, sizeof(__pyx_k_TA_CDLDRAGONFLYDOJI), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLDRAGONFLYDOJI */
+  {__pyx_k_TA_CDLENGULFING, sizeof(__pyx_k_TA_CDLENGULFING), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLENGULFING */
+  {__pyx_k_TA_CDLEVENINGDOJISTAR, sizeof(__pyx_k_TA_CDLEVENINGDOJISTAR), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLEVENINGDOJISTAR */
+  {__pyx_k_TA_CDLEVENINGSTAR, sizeof(__pyx_k_TA_CDLEVENINGSTAR), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLEVENINGSTAR */
+  {__pyx_k_TA_CDLGAPSIDESIDEWHITE, sizeof(__pyx_k_TA_CDLGAPSIDESIDEWHITE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLGAPSIDESIDEWHITE */
+  {__pyx_k_TA_CDLGRAVESTONEDOJI, sizeof(__pyx_k_TA_CDLGRAVESTONEDOJI), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLGRAVESTONEDOJI */
+  {__pyx_k_TA_CDLHAMMER, sizeof(__pyx_k_TA_CDLHAMMER), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLHAMMER */
+  {__pyx_k_TA_CDLHANGINGMAN, sizeof(__pyx_k_TA_CDLHANGINGMAN), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLHANGINGMAN */
+  {__pyx_k_TA_CDLHARAMI, sizeof(__pyx_k_TA_CDLHARAMI), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLHARAMI */
+  {__pyx_k_TA_CDLHARAMICROSS, sizeof(__pyx_k_TA_CDLHARAMICROSS), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLHARAMICROSS */
+  {__pyx_k_TA_CDLHIGHWAVE, sizeof(__pyx_k_TA_CDLHIGHWAVE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLHIGHWAVE */
+  {__pyx_k_TA_CDLHIKKAKE, sizeof(__pyx_k_TA_CDLHIKKAKE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLHIKKAKE */
+  {__pyx_k_TA_CDLHIKKAKEMOD, sizeof(__pyx_k_TA_CDLHIKKAKEMOD), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLHIKKAKEMOD */
+  {__pyx_k_TA_CDLHOMINGPIGEON, sizeof(__pyx_k_TA_CDLHOMINGPIGEON), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLHOMINGPIGEON */
+  {__pyx_k_TA_CDLIDENTICAL3CROWS, sizeof(__pyx_k_TA_CDLIDENTICAL3CROWS), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLIDENTICAL3CROWS */
+  {__pyx_k_TA_CDLINNECK, sizeof(__pyx_k_TA_CDLINNECK), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLINNECK */
+  {__pyx_k_TA_CDLINVERTEDHAMMER, sizeof(__pyx_k_TA_CDLINVERTEDHAMMER), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLINVERTEDHAMMER */
+  {__pyx_k_TA_CDLKICKING, sizeof(__pyx_k_TA_CDLKICKING), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLKICKING */
+  {__pyx_k_TA_CDLKICKINGBYLENGTH, sizeof(__pyx_k_TA_CDLKICKINGBYLENGTH), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLKICKINGBYLENGTH */
+  {__pyx_k_TA_CDLLADDERBOTTOM, sizeof(__pyx_k_TA_CDLLADDERBOTTOM), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLLADDERBOTTOM */
+  {__pyx_k_TA_CDLLONGLEGGEDDOJI, sizeof(__pyx_k_TA_CDLLONGLEGGEDDOJI), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLLONGLEGGEDDOJI */
+  {__pyx_k_TA_CDLLONGLINE, sizeof(__pyx_k_TA_CDLLONGLINE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLLONGLINE */
+  {__pyx_k_TA_CDLMARUBOZU, sizeof(__pyx_k_TA_CDLMARUBOZU), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLMARUBOZU */
+  {__pyx_k_TA_CDLMATCHINGLOW, sizeof(__pyx_k_TA_CDLMATCHINGLOW), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLMATCHINGLOW */
+  {__pyx_k_TA_CDLMATHOLD, sizeof(__pyx_k_TA_CDLMATHOLD), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLMATHOLD */
+  {__pyx_k_TA_CDLMORNINGDOJISTAR, sizeof(__pyx_k_TA_CDLMORNINGDOJISTAR), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLMORNINGDOJISTAR */
+  {__pyx_k_TA_CDLMORNINGSTAR, sizeof(__pyx_k_TA_CDLMORNINGSTAR), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLMORNINGSTAR */
+  {__pyx_k_TA_CDLONNECK, sizeof(__pyx_k_TA_CDLONNECK), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLONNECK */
+  {__pyx_k_TA_CDLPIERCING, sizeof(__pyx_k_TA_CDLPIERCING), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLPIERCING */
+  {__pyx_k_TA_CDLRICKSHAWMAN, sizeof(__pyx_k_TA_CDLRICKSHAWMAN), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLRICKSHAWMAN */
+  {__pyx_k_TA_CDLRISEFALL3METHODS, sizeof(__pyx_k_TA_CDLRISEFALL3METHODS), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLRISEFALL3METHODS */
+  {__pyx_k_TA_CDLSEPARATINGLINES, sizeof(__pyx_k_TA_CDLSEPARATINGLINES), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLSEPARATINGLINES */
+  {__pyx_k_TA_CDLSHOOTINGSTAR, sizeof(__pyx_k_TA_CDLSHOOTINGSTAR), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLSHOOTINGSTAR */
+  {__pyx_k_TA_CDLSHORTLINE, sizeof(__pyx_k_TA_CDLSHORTLINE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLSHORTLINE */
+  {__pyx_k_TA_CDLSPINNINGTOP, sizeof(__pyx_k_TA_CDLSPINNINGTOP), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLSPINNINGTOP */
+  {__pyx_k_TA_CDLSTALLEDPATTERN, sizeof(__pyx_k_TA_CDLSTALLEDPATTERN), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLSTALLEDPATTERN */
+  {__pyx_k_TA_CDLSTICKSANDWICH, sizeof(__pyx_k_TA_CDLSTICKSANDWICH), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLSTICKSANDWICH */
+  {__pyx_k_TA_CDLTAKURI, sizeof(__pyx_k_TA_CDLTAKURI), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLTAKURI */
+  {__pyx_k_TA_CDLTASUKIGAP, sizeof(__pyx_k_TA_CDLTASUKIGAP), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLTASUKIGAP */
+  {__pyx_k_TA_CDLTHRUSTING, sizeof(__pyx_k_TA_CDLTHRUSTING), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLTHRUSTING */
+  {__pyx_k_TA_CDLTRISTAR, sizeof(__pyx_k_TA_CDLTRISTAR), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLTRISTAR */
+  {__pyx_k_TA_CDLUNIQUE3RIVER, sizeof(__pyx_k_TA_CDLUNIQUE3RIVER), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLUNIQUE3RIVER */
+  {__pyx_k_TA_CDLUPSIDEGAP2CROWS, sizeof(__pyx_k_TA_CDLUPSIDEGAP2CROWS), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLUPSIDEGAP2CROWS */
+  {__pyx_k_TA_CDLXSIDEGAP3METHODS, sizeof(__pyx_k_TA_CDLXSIDEGAP3METHODS), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CDLXSIDEGAP3METHODS */
+  {__pyx_k_TA_CEIL, sizeof(__pyx_k_TA_CEIL), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CEIL */
+  {__pyx_k_TA_CMO, sizeof(__pyx_k_TA_CMO), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CMO */
+  {__pyx_k_TA_CORREL, sizeof(__pyx_k_TA_CORREL), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_CORREL */
+  {__pyx_k_TA_COS, sizeof(__pyx_k_TA_COS), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_COS */
+  {__pyx_k_TA_COSH, sizeof(__pyx_k_TA_COSH), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_COSH */
+  {__pyx_k_TA_DEMA, sizeof(__pyx_k_TA_DEMA), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_DEMA */
+  {__pyx_k_TA_DIV, sizeof(__pyx_k_TA_DIV), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_DIV */
+  {__pyx_k_TA_DX, sizeof(__pyx_k_TA_DX), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_DX */
+  {__pyx_k_TA_EMA, sizeof(__pyx_k_TA_EMA), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_EMA */
+  {__pyx_k_TA_EXP, sizeof(__pyx_k_TA_EXP), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_EXP */
+  {__pyx_k_TA_FLOOR, sizeof(__pyx_k_TA_FLOOR), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_FLOOR */
+  {__pyx_k_TA_FUNCTION_NAMES, sizeof(__pyx_k_TA_FUNCTION_NAMES), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_FUNCTION_NAMES */
+  {__pyx_k_TA_FUNC_FLAGS, sizeof(__pyx_k_TA_FUNC_FLAGS), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_FUNC_FLAGS */
+  {__pyx_k_TA_FuncTableAlloc, sizeof(__pyx_k_TA_FuncTableAlloc), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_FuncTableAlloc */
+  {__pyx_k_TA_FuncTableFree, sizeof(__pyx_k_TA_FuncTableFree), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_FuncTableFree */
+  {__pyx_k_TA_GetFuncHandle, sizeof(__pyx_k_TA_GetFuncHandle), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_GetFuncHandle */
+  {__pyx_k_TA_GetFuncInfo, sizeof(__pyx_k_TA_GetFuncInfo), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_GetFuncInfo */
+  {__pyx_k_TA_GetInputParameterInfo, sizeof(__pyx_k_TA_GetInputParameterInfo), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_GetInputParameterInfo */
+  {__pyx_k_TA_GetLookback, sizeof(__pyx_k_TA_GetLookback), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_GetLookback */
+  {__pyx_k_TA_GetOptInputParameterInfo, sizeof(__pyx_k_TA_GetOptInputParameterInfo), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_GetOptInputParameterInfo */
+  {__pyx_k_TA_GetOutputParameterInfo, sizeof(__pyx_k_TA_GetOutputParameterInfo), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_GetOutputParameterInfo */
+  {__pyx_k_TA_GroupTableAlloc, sizeof(__pyx_k_TA_GroupTableAlloc), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_GroupTableAlloc */
+  {__pyx_k_TA_GroupTableFree, sizeof(__pyx_k_TA_GroupTableFree), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_GroupTableFree */
+  {__pyx_k_TA_HT_DCPERIOD, sizeof(__pyx_k_TA_HT_DCPERIOD), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_HT_DCPERIOD */
+  {__pyx_k_TA_HT_DCPHASE, sizeof(__pyx_k_TA_HT_DCPHASE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_HT_DCPHASE */
+  {__pyx_k_TA_HT_PHASOR, sizeof(__pyx_k_TA_HT_PHASOR), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_HT_PHASOR */
+  {__pyx_k_TA_HT_SINE, sizeof(__pyx_k_TA_HT_SINE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_HT_SINE */
+  {__pyx_k_TA_HT_TRENDLINE, sizeof(__pyx_k_TA_HT_TRENDLINE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_HT_TRENDLINE */
+  {__pyx_k_TA_HT_TRENDMODE, sizeof(__pyx_k_TA_HT_TRENDMODE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_HT_TRENDMODE */
+  {__pyx_k_TA_IMI, sizeof(__pyx_k_TA_IMI), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_IMI */
+  {__pyx_k_TA_INPUT_FLAGS, sizeof(__pyx_k_TA_INPUT_FLAGS), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_INPUT_FLAGS */
+  {__pyx_k_TA_Initialize, sizeof(__pyx_k_TA_Initialize), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_Initialize */
+  {__pyx_k_TA_KAMA, sizeof(__pyx_k_TA_KAMA), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_KAMA */
+  {__pyx_k_TA_LINEARREG, sizeof(__pyx_k_TA_LINEARREG), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_LINEARREG */
+  {__pyx_k_TA_LINEARREG_ANGLE, sizeof(__pyx_k_TA_LINEARREG_ANGLE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_LINEARREG_ANGLE */
+  {__pyx_k_TA_LINEARREG_INTERCEPT, sizeof(__pyx_k_TA_LINEARREG_INTERCEPT), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_LINEARREG_INTERCEPT */
+  {__pyx_k_TA_LINEARREG_SLOPE, sizeof(__pyx_k_TA_LINEARREG_SLOPE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_LINEARREG_SLOPE */
+  {__pyx_k_TA_LN, sizeof(__pyx_k_TA_LN), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_LN */
+  {__pyx_k_TA_LOG10, sizeof(__pyx_k_TA_LOG10), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_LOG10 */
+  {__pyx_k_TA_MA, sizeof(__pyx_k_TA_MA), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_MA */
+  {__pyx_k_TA_MACD, sizeof(__pyx_k_TA_MACD), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_MACD */
+  {__pyx_k_TA_MACDEXT, sizeof(__pyx_k_TA_MACDEXT), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_MACDEXT */
+  {__pyx_k_TA_MACDFIX, sizeof(__pyx_k_TA_MACDFIX), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_MACDFIX */
+  {__pyx_k_TA_MAMA, sizeof(__pyx_k_TA_MAMA), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_MAMA */
+  {__pyx_k_TA_MAVP, sizeof(__pyx_k_TA_MAVP), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_MAVP */
+  {__pyx_k_TA_MAX, sizeof(__pyx_k_TA_MAX), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_MAX */
+  {__pyx_k_TA_MAXINDEX, sizeof(__pyx_k_TA_MAXINDEX), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_MAXINDEX */
+  {__pyx_k_TA_MEDPRICE, sizeof(__pyx_k_TA_MEDPRICE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_MEDPRICE */
+  {__pyx_k_TA_MFI, sizeof(__pyx_k_TA_MFI), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_MFI */
+  {__pyx_k_TA_MIDPOINT, sizeof(__pyx_k_TA_MIDPOINT), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_MIDPOINT */
+  {__pyx_k_TA_MIDPRICE, sizeof(__pyx_k_TA_MIDPRICE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_MIDPRICE */
+  {__pyx_k_TA_MIN, sizeof(__pyx_k_TA_MIN), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_MIN */
+  {__pyx_k_TA_MININDEX, sizeof(__pyx_k_TA_MININDEX), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_MININDEX */
+  {__pyx_k_TA_MINMAX, sizeof(__pyx_k_TA_MINMAX), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_MINMAX */
+  {__pyx_k_TA_MINMAXINDEX, sizeof(__pyx_k_TA_MINMAXINDEX), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_MINMAXINDEX */
+  {__pyx_k_TA_MINUS_DI, sizeof(__pyx_k_TA_MINUS_DI), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_MINUS_DI */
+  {__pyx_k_TA_MINUS_DM, sizeof(__pyx_k_TA_MINUS_DM), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_MINUS_DM */
+  {__pyx_k_TA_MOM, sizeof(__pyx_k_TA_MOM), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_MOM */
+  {__pyx_k_TA_MULT, sizeof(__pyx_k_TA_MULT), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_MULT */
+  {__pyx_k_TA_NATR, sizeof(__pyx_k_TA_NATR), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_NATR */
+  {__pyx_k_TA_OBV, sizeof(__pyx_k_TA_OBV), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_OBV */
+  {__pyx_k_TA_OUTPUT_FLAGS, sizeof(__pyx_k_TA_OUTPUT_FLAGS), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_OUTPUT_FLAGS */
+  {__pyx_k_TA_PLUS_DI, sizeof(__pyx_k_TA_PLUS_DI), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_PLUS_DI */
+  {__pyx_k_TA_PLUS_DM, sizeof(__pyx_k_TA_PLUS_DM), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_PLUS_DM */
+  {__pyx_k_TA_PPO, sizeof(__pyx_k_TA_PPO), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_PPO */
+  {__pyx_k_TA_ParamHolderAlloc, sizeof(__pyx_k_TA_ParamHolderAlloc), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_ParamHolderAlloc */
+  {__pyx_k_TA_ParamHolderFree, sizeof(__pyx_k_TA_ParamHolderFree), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_ParamHolderFree */
+  {__pyx_k_TA_ROC, sizeof(__pyx_k_TA_ROC), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_ROC */
+  {__pyx_k_TA_ROCP, sizeof(__pyx_k_TA_ROCP), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_ROCP */
+  {__pyx_k_TA_ROCR, sizeof(__pyx_k_TA_ROCR), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_ROCR */
+  {__pyx_k_TA_ROCR100, sizeof(__pyx_k_TA_ROCR100), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_ROCR100 */
+  {__pyx_k_TA_RSI, sizeof(__pyx_k_TA_RSI), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_RSI */
+  {__pyx_k_TA_RestoreCandleDefaultSettings, sizeof(__pyx_k_TA_RestoreCandleDefaultSettings), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_RestoreCandleDefaultSettings */
+  {__pyx_k_TA_SAR, sizeof(__pyx_k_TA_SAR), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_SAR */
+  {__pyx_k_TA_SAREXT, sizeof(__pyx_k_TA_SAREXT), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_SAREXT */
+  {__pyx_k_TA_SIN, sizeof(__pyx_k_TA_SIN), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_SIN */
+  {__pyx_k_TA_SINH, sizeof(__pyx_k_TA_SINH), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_SINH */
+  {__pyx_k_TA_SMA, sizeof(__pyx_k_TA_SMA), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_SMA */
+  {__pyx_k_TA_SQRT, sizeof(__pyx_k_TA_SQRT), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_SQRT */
+  {__pyx_k_TA_STDDEV, sizeof(__pyx_k_TA_STDDEV), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_STDDEV */
+  {__pyx_k_TA_STOCH, sizeof(__pyx_k_TA_STOCH), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_STOCH */
+  {__pyx_k_TA_STOCHF, sizeof(__pyx_k_TA_STOCHF), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_STOCHF */
+  {__pyx_k_TA_STOCHRSI, sizeof(__pyx_k_TA_STOCHRSI), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_STOCHRSI */
+  {__pyx_k_TA_SUB, sizeof(__pyx_k_TA_SUB), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_SUB */
+  {__pyx_k_TA_SUM, sizeof(__pyx_k_TA_SUM), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_SUM */
+  {__pyx_k_TA_SetCandleSettings, sizeof(__pyx_k_TA_SetCandleSettings), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_SetCandleSettings */
+  {__pyx_k_TA_SetCompatibility, sizeof(__pyx_k_TA_SetCompatibility), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_SetCompatibility */
+  {__pyx_k_TA_SetOptInputParamInteger, sizeof(__pyx_k_TA_SetOptInputParamInteger), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_SetOptInputParamInteger */
+  {__pyx_k_TA_SetOptInputParamReal, sizeof(__pyx_k_TA_SetOptInputParamReal), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_SetOptInputParamReal */
+  {__pyx_k_TA_SetUnstablePeriod, sizeof(__pyx_k_TA_SetUnstablePeriod), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_SetUnstablePeriod */
+  {__pyx_k_TA_Shutdown, sizeof(__pyx_k_TA_Shutdown), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_Shutdown */
+  {__pyx_k_TA_T3, sizeof(__pyx_k_TA_T3), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_T3 */
+  {__pyx_k_TA_TAN, sizeof(__pyx_k_TA_TAN), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_TAN */
+  {__pyx_k_TA_TANH, sizeof(__pyx_k_TA_TANH), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_TANH */
+  {__pyx_k_TA_TEMA, sizeof(__pyx_k_TA_TEMA), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_TEMA */
+  {__pyx_k_TA_TRANGE, sizeof(__pyx_k_TA_TRANGE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_TRANGE */
+  {__pyx_k_TA_TRIMA, sizeof(__pyx_k_TA_TRIMA), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_TRIMA */
+  {__pyx_k_TA_TRIX, sizeof(__pyx_k_TA_TRIX), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_TRIX */
+  {__pyx_k_TA_TSF, sizeof(__pyx_k_TA_TSF), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_TSF */
+  {__pyx_k_TA_TYPPRICE, sizeof(__pyx_k_TA_TYPPRICE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_TYPPRICE */
+  {__pyx_k_TA_ULTOSC, sizeof(__pyx_k_TA_ULTOSC), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_ULTOSC */
+  {__pyx_k_TA_VAR, sizeof(__pyx_k_TA_VAR), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_VAR */
+  {__pyx_k_TA_WCLPRICE, sizeof(__pyx_k_TA_WCLPRICE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_WCLPRICE */
+  {__pyx_k_TA_WILLR, sizeof(__pyx_k_TA_WILLR), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_WILLR */
+  {__pyx_k_TA_WMA, sizeof(__pyx_k_TA_WMA), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TA_WMA */
+  {__pyx_k_TEMA, sizeof(__pyx_k_TEMA), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TEMA */
+  {__pyx_k_TRANGE, sizeof(__pyx_k_TRANGE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TRANGE */
+  {__pyx_k_TRIMA, sizeof(__pyx_k_TRIMA), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TRIMA */
+  {__pyx_k_TRIX, sizeof(__pyx_k_TRIX), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TRIX */
+  {__pyx_k_TSF, sizeof(__pyx_k_TSF), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TSF */
+  {__pyx_k_TYPPRICE, sizeof(__pyx_k_TYPPRICE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TYPPRICE */
+  {__pyx_k_This_is_a_pythonic_wrapper_arou, sizeof(__pyx_k_This_is_a_pythonic_wrapper_arou), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_This_is_a_pythonic_wrapper_arou */
+  {__pyx_k_Too_many_price_arguments_expecte, sizeof(__pyx_k_Too_many_price_arguments_expecte), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Too_many_price_arguments_expecte */
+  {__pyx_k_Triangular_Moving_Average, sizeof(__pyx_k_Triangular_Moving_Average), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Triangular_Moving_Average */
+  {__pyx_k_Triple_Exponential_Moving_Averag, sizeof(__pyx_k_Triple_Exponential_Moving_Averag), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Triple_Exponential_Moving_Averag */
+  {__pyx_k_Triple_Generalized_Double_Expone, sizeof(__pyx_k_Triple_Generalized_Double_Expone), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Triple_Generalized_Double_Expone */
+  {__pyx_k_TypeError, sizeof(__pyx_k_TypeError), 0, 1, 1}, /* PyObject cname: __pyx_n_u_TypeError */
+  {__pyx_k_ULTOSC, sizeof(__pyx_k_ULTOSC), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ULTOSC */
+  {__pyx_k_Unknown_Error, sizeof(__pyx_k_Unknown_Error), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Unknown_Error */
+  {__pyx_k_Unknown_Error_TA_UNKNOWN_ERR, sizeof(__pyx_k_Unknown_Error_TA_UNKNOWN_ERR), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Unknown_Error_TA_UNKNOWN_ERR */
+  {__pyx_k_VAR, sizeof(__pyx_k_VAR), 0, 1, 1}, /* PyObject cname: __pyx_n_u_VAR */
+  {__pyx_k_Values_represent_a_lower_limit, sizeof(__pyx_k_Values_represent_a_lower_limit), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Values_represent_a_lower_limit */
+  {__pyx_k_Values_represent_an_upper_limit, sizeof(__pyx_k_Values_represent_an_upper_limit), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Values_represent_an_upper_limit */
+  {__pyx_k_WCLPRICE, sizeof(__pyx_k_WCLPRICE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_WCLPRICE */
+  {__pyx_k_WILLR, sizeof(__pyx_k_WILLR), 0, 1, 1}, /* PyObject cname: __pyx_n_u_WILLR */
+  {__pyx_k_WMA, sizeof(__pyx_k_WMA), 0, 1, 1}, /* PyObject cname: __pyx_n_u_WMA */
+  {__pyx_k_Weighted_Moving_Average, sizeof(__pyx_k_Weighted_Moving_Average), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_Weighted_Moving_Average */
+  {__pyx_k__10, sizeof(__pyx_k__10), 0, 1, 0}, /* PyObject cname: __pyx_kp_u__10 */
+  {__pyx_k__11, sizeof(__pyx_k__11), 0, 1, 0}, /* PyObject cname: __pyx_kp_u__11 */
+  {__pyx_k__12, sizeof(__pyx_k__12), 0, 1, 0}, /* PyObject cname: __pyx_kp_u__12 */
+  {__pyx_k__13, sizeof(__pyx_k__13), 0, 1, 0}, /* PyObject cname: __pyx_kp_u__13 */
+  {__pyx_k__14, sizeof(__pyx_k__14), 0, 1, 0}, /* PyObject cname: __pyx_kp_u__14 */
+  {__pyx_k__15, sizeof(__pyx_k__15), 0, 1, 0}, /* PyObject cname: __pyx_kp_u__15 */
+  {__pyx_k__2, sizeof(__pyx_k__2), 0, 1, 0}, /* PyObject cname: __pyx_kp_u__2 */
+  {__pyx_k__3, sizeof(__pyx_k__3), 0, 1, 0}, /* PyObject cname: __pyx_kp_u__3 */
+  {__pyx_k__4, sizeof(__pyx_k__4), 0, 1, 0}, /* PyObject cname: __pyx_kp_u__4 */
+  {__pyx_k__5, sizeof(__pyx_k__5), 0, 1, 0}, /* PyObject cname: __pyx_kp_u__5 */
+  {__pyx_k__6, sizeof(__pyx_k__6), 0, 1, 0}, /* PyObject cname: __pyx_kp_u__6 */
+  {__pyx_k__7, sizeof(__pyx_k__7), 0, 1, 0}, /* PyObject cname: __pyx_kp_u__7 */
+  {__pyx_k__8, sizeof(__pyx_k__8), 0, 1, 0}, /* PyObject cname: __pyx_kp_u__8 */
+  {__pyx_k__9, sizeof(__pyx_k__9), 0, 1, 0}, /* PyObject cname: __pyx_kp_u__9 */
+  {__pyx_k_acceleration, sizeof(__pyx_k_acceleration), 0, 1, 1}, /* PyObject cname: __pyx_n_u_acceleration */
+  {__pyx_k_accelerationinitlong, sizeof(__pyx_k_accelerationinitlong), 0, 1, 1}, /* PyObject cname: __pyx_n_u_accelerationinitlong */
+  {__pyx_k_accelerationinitshort, sizeof(__pyx_k_accelerationinitshort), 0, 1, 1}, /* PyObject cname: __pyx_n_u_accelerationinitshort */
+  {__pyx_k_accelerationlong, sizeof(__pyx_k_accelerationlong), 0, 1, 1}, /* PyObject cname: __pyx_n_u_accelerationlong */
+  {__pyx_k_accelerationmaxlong, sizeof(__pyx_k_accelerationmaxlong), 0, 1, 1}, /* PyObject cname: __pyx_n_u_accelerationmaxlong */
+  {__pyx_k_accelerationmaxshort, sizeof(__pyx_k_accelerationmaxshort), 0, 1, 1}, /* PyObject cname: __pyx_n_u_accelerationmaxshort */
+  {__pyx_k_accelerationshort, sizeof(__pyx_k_accelerationshort), 0, 1, 1}, /* PyObject cname: __pyx_n_u_accelerationshort */
+  {__pyx_k_add_note, sizeof(__pyx_k_add_note), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_add_note */
+  {__pyx_k_all, sizeof(__pyx_k_all), 0, 1, 1}, /* PyObject cname: __pyx_n_u_all */
+  {__pyx_k_any_ndarray, sizeof(__pyx_k_any_ndarray), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_any_ndarray */
+  {__pyx_k_append, sizeof(__pyx_k_append), 0, 1, 1}, /* PyObject cname: __pyx_n_u_append */
+  {__pyx_k_arg, sizeof(__pyx_k_arg), 0, 1, 1}, /* PyObject cname: __pyx_n_u_arg */
+  {__pyx_k_args, sizeof(__pyx_k_args), 0, 1, 1}, /* PyObject cname: __pyx_n_u_args */
+  {__pyx_k_ascii, sizeof(__pyx_k_ascii), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ascii */
+  {__pyx_k_astype, sizeof(__pyx_k_astype), 0, 1, 1}, /* PyObject cname: __pyx_n_u_astype */
+  {__pyx_k_asyncio_coroutines, sizeof(__pyx_k_asyncio_coroutines), 0, 1, 1}, /* PyObject cname: __pyx_n_u_asyncio_coroutines */
+  {__pyx_k_avgperiod, sizeof(__pyx_k_avgperiod), 0, 1, 1}, /* PyObject cname: __pyx_n_u_avgperiod */
+  {__pyx_k_b, sizeof(__pyx_k_b), 0, 1, 1}, /* PyObject cname: __pyx_n_u_b */
+  {__pyx_k_begidx, sizeof(__pyx_k_begidx), 0, 1, 1}, /* PyObject cname: __pyx_n_u_begidx */
+  {__pyx_k_bytes2str, sizeof(__pyx_k_bytes2str), 0, 1, 1}, /* PyObject cname: __pyx_n_u_bytes2str */
+  {__pyx_k_call, sizeof(__pyx_k_call), 0, 1, 1}, /* PyObject cname: __pyx_n_u_call */
+  {__pyx_k_call_function, sizeof(__pyx_k_call_function), 0, 1, 1}, /* PyObject cname: __pyx_n_u_call_function */
+  {__pyx_k_check_opt_input_value, sizeof(__pyx_k_check_opt_input_value), 0, 1, 1}, /* PyObject cname: __pyx_n_u_check_opt_input_value */
+  {__pyx_k_class_getitem, sizeof(__pyx_k_class_getitem), 0, 1, 1}, /* PyObject cname: __pyx_n_u_class_getitem */
+  {__pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 1, 1}, /* PyObject cname: __pyx_n_u_cline_in_traceback */
+  {__pyx_k_clone, sizeof(__pyx_k_clone), 0, 1, 1}, /* PyObject cname: __pyx_n_u_clone */
+  {__pyx_k_close, sizeof(__pyx_k_close), 0, 1, 1}, /* PyObject cname: __pyx_n_u_close */
+  {__pyx_k_close_data, sizeof(__pyx_k_close_data), 0, 1, 1}, /* PyObject cname: __pyx_n_u_close_data */
+  {__pyx_k_collections, sizeof(__pyx_k_collections), 0, 1, 1}, /* PyObject cname: __pyx_n_u_collections */
+  {__pyx_k_column_stack, sizeof(__pyx_k_column_stack), 0, 1, 1}, /* PyObject cname: __pyx_n_u_column_stack */
+  {__pyx_k_columns, sizeof(__pyx_k_columns), 0, 1, 1}, /* PyObject cname: __pyx_n_u_columns */
+  {__pyx_k_copy, sizeof(__pyx_k_copy), 0, 1, 1}, /* PyObject cname: __pyx_n_u_copy */
+  {__pyx_k_d, sizeof(__pyx_k_d), 0, 1, 1}, /* PyObject cname: __pyx_n_u_d */
+  {__pyx_k_decode, sizeof(__pyx_k_decode), 0, 1, 1}, /* PyObject cname: __pyx_n_u_decode */
+  {__pyx_k_default_value, sizeof(__pyx_k_default_value), 0, 1, 1}, /* PyObject cname: __pyx_n_u_default_value */
+  {__pyx_k_defaults, sizeof(__pyx_k_defaults), 0, 1, 1}, /* PyObject cname: __pyx_n_u_defaults */
+  {__pyx_k_display_name, sizeof(__pyx_k_display_name), 0, 1, 1}, /* PyObject cname: __pyx_n_u_display_name */
+  {__pyx_k_display_name_s_group_s, sizeof(__pyx_k_display_name_s_group_s), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_display_name_s_group_s */
+  {__pyx_k_doc, sizeof(__pyx_k_doc), 0, 1, 1}, /* PyObject cname: __pyx_n_u_doc */
+  {__pyx_k_docs, sizeof(__pyx_k_docs), 0, 1, 1}, /* PyObject cname: __pyx_n_u_docs */
+  {__pyx_k_documentation, sizeof(__pyx_k_documentation), 0, 1, 1}, /* PyObject cname: __pyx_n_u_documentation */
+  {__pyx_k_empty, sizeof(__pyx_k_empty), 0, 1, 1}, /* PyObject cname: __pyx_n_u_empty */
+  {__pyx_k_endidx, sizeof(__pyx_k_endidx), 0, 1, 1}, /* PyObject cname: __pyx_n_u_endidx */
+  {__pyx_k_enumerate, sizeof(__pyx_k_enumerate), 0, 1, 1}, /* PyObject cname: __pyx_n_u_enumerate */
+  {__pyx_k_expected, sizeof(__pyx_k_expected), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_expected */
+  {__pyx_k_factor, sizeof(__pyx_k_factor), 0, 1, 1}, /* PyObject cname: __pyx_n_u_factor */
+  {__pyx_k_fastd_matype, sizeof(__pyx_k_fastd_matype), 0, 1, 1}, /* PyObject cname: __pyx_n_u_fastd_matype */
+  {__pyx_k_fastd_period, sizeof(__pyx_k_fastd_period), 0, 1, 1}, /* PyObject cname: __pyx_n_u_fastd_period */
+  {__pyx_k_fastk_period, sizeof(__pyx_k_fastk_period), 0, 1, 1}, /* PyObject cname: __pyx_n_u_fastk_period */
+  {__pyx_k_fastlimit, sizeof(__pyx_k_fastlimit), 0, 1, 1}, /* PyObject cname: __pyx_n_u_fastlimit */
+  {__pyx_k_fastmatype, sizeof(__pyx_k_fastmatype), 0, 1, 1}, /* PyObject cname: __pyx_n_u_fastmatype */
+  {__pyx_k_fastperiod, sizeof(__pyx_k_fastperiod), 0, 1, 1}, /* PyObject cname: __pyx_n_u_fastperiod */
+  {__pyx_k_flag, sizeof(__pyx_k_flag), 0, 1, 1}, /* PyObject cname: __pyx_n_u_flag */
+  {__pyx_k_flags, sizeof(__pyx_k_flags), 0, 1, 1}, /* PyObject cname: __pyx_n_u_flags */
+  {__pyx_k_flags_lookup_dict, sizeof(__pyx_k_flags_lookup_dict), 0, 1, 1}, /* PyObject cname: __pyx_n_u_flags_lookup_dict */
+  {__pyx_k_func, sizeof(__pyx_k_func), 0, 1, 1}, /* PyObject cname: __pyx_n_u_func */
+  {__pyx_k_func_args, sizeof(__pyx_k_func_args), 0, 1, 1}, /* PyObject cname: __pyx_n_u_func_args */
+  {__pyx_k_func_info, sizeof(__pyx_k_func_info), 0, 1, 1}, /* PyObject cname: __pyx_n_u_func_info */
+  {__pyx_k_func_line, sizeof(__pyx_k_func_line), 0, 1, 1}, /* PyObject cname: __pyx_n_u_func_line */
+  {__pyx_k_func_object, sizeof(__pyx_k_func_object), 0, 1, 1}, /* PyObject cname: __pyx_n_u_func_object */
+  {__pyx_k_function_failed_with_error_code, sizeof(__pyx_k_function_failed_with_error_code), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_function_failed_with_error_code */
+  {__pyx_k_function_flags, sizeof(__pyx_k_function_flags), 0, 1, 1}, /* PyObject cname: __pyx_n_u_function_flags */
+  {__pyx_k_function_name, sizeof(__pyx_k_function_name), 0, 1, 1}, /* PyObject cname: __pyx_n_u_function_name */
+  {__pyx_k_functions, sizeof(__pyx_k_functions), 0, 1, 1}, /* PyObject cname: __pyx_n_u_functions */
+  {__pyx_k_get_defaults_and_docs, sizeof(__pyx_k_get_defaults_and_docs), 0, 1, 1}, /* PyObject cname: __pyx_n_u_get_defaults_and_docs */
+  {__pyx_k_get_flags, sizeof(__pyx_k_get_flags), 0, 1, 1}, /* PyObject cname: __pyx_n_u_get_flags */
+  {__pyx_k_get_input_arrays, sizeof(__pyx_k_get_input_arrays), 0, 1, 1}, /* PyObject cname: __pyx_n_u_get_input_arrays */
+  {__pyx_k_get_input_names, sizeof(__pyx_k_get_input_names), 0, 1, 1}, /* PyObject cname: __pyx_n_u_get_input_names */
+  {__pyx_k_get_opt_input_value, sizeof(__pyx_k_get_opt_input_value), 0, 1, 1}, /* PyObject cname: __pyx_n_u_get_opt_input_value */
+  {__pyx_k_get_parameters, sizeof(__pyx_k_get_parameters), 0, 1, 1}, /* PyObject cname: __pyx_n_u_get_parameters */
+  {__pyx_k_getitem, sizeof(__pyx_k_getitem), 0, 1, 1}, /* PyObject cname: __pyx_n_u_getitem */
+  {__pyx_k_got, sizeof(__pyx_k_got), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_got */
+  {__pyx_k_group, sizeof(__pyx_k_group), 0, 1, 1}, /* PyObject cname: __pyx_n_u_group */
+  {__pyx_k_groups, sizeof(__pyx_k_groups), 0, 1, 1}, /* PyObject cname: __pyx_n_u_groups */
+  {__pyx_k_help, sizeof(__pyx_k_help), 0, 1, 1}, /* PyObject cname: __pyx_n_u_help */
+  {__pyx_k_high, sizeof(__pyx_k_high), 0, 1, 1}, /* PyObject cname: __pyx_n_u_high */
+  {__pyx_k_high_data, sizeof(__pyx_k_high_data), 0, 1, 1}, /* PyObject cname: __pyx_n_u_high_data */
+  {__pyx_k_holder, sizeof(__pyx_k_holder), 0, 1, 1}, /* PyObject cname: __pyx_n_u_holder */
+  {__pyx_k_i, sizeof(__pyx_k_i), 0, 1, 1}, /* PyObject cname: __pyx_n_u_i */
+  {__pyx_k_id, sizeof(__pyx_k_id), 0, 1, 1}, /* PyObject cname: __pyx_n_u_id */
+  {__pyx_k_idx, sizeof(__pyx_k_idx), 0, 1, 1}, /* PyObject cname: __pyx_n_u_idx */
+  {__pyx_k_import_error, sizeof(__pyx_k_import_error), 0, 1, 1}, /* PyObject cname: __pyx_n_u_import_error */
+  {__pyx_k_in, sizeof(__pyx_k_in), 0, 1, 1}, /* PyObject cname: __pyx_n_u_in */
+  {__pyx_k_index, sizeof(__pyx_k_index), 0, 1, 1}, /* PyObject cname: __pyx_n_u_index */
+  {__pyx_k_info, sizeof(__pyx_k_info), 0, 1, 1}, /* PyObject cname: __pyx_n_u_info */
+  {__pyx_k_init, sizeof(__pyx_k_init), 0, 1, 1}, /* PyObject cname: __pyx_n_u_init */
+  {__pyx_k_initializing, sizeof(__pyx_k_initializing), 0, 1, 1}, /* PyObject cname: __pyx_n_u_initializing */
+  {__pyx_k_input_array_has_wrong_dimensions, sizeof(__pyx_k_input_array_has_wrong_dimensions), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_input_array_has_wrong_dimensions */
+  {__pyx_k_input_array_lengths_are_differen, sizeof(__pyx_k_input_array_lengths_are_differen), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_input_array_lengths_are_differen */
+  {__pyx_k_input_array_type_is_not_double, sizeof(__pyx_k_input_array_type_is_not_double), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_input_array_type_is_not_double */
+  {__pyx_k_input_arrays, sizeof(__pyx_k_input_arrays), 0, 1, 1}, /* PyObject cname: __pyx_n_u_input_arrays */
+  {__pyx_k_input_arrays_2, sizeof(__pyx_k_input_arrays_2), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_input_arrays_2 */
+  {__pyx_k_input_arrays_parameter_missing_r, sizeof(__pyx_k_input_arrays_parameter_missing_r), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_input_arrays_parameter_missing_r */
+  {__pyx_k_input_name, sizeof(__pyx_k_input_name), 0, 1, 1}, /* PyObject cname: __pyx_n_u_input_name */
+  {__pyx_k_input_names, sizeof(__pyx_k_input_names), 0, 1, 1}, /* PyObject cname: __pyx_n_u_input_names */
+  {__pyx_k_input_price_series_names, sizeof(__pyx_k_input_price_series_names), 0, 1, 1}, /* PyObject cname: __pyx_n_u_input_price_series_names */
+  {__pyx_k_input_price_series_names_2, sizeof(__pyx_k_input_price_series_names_2), 0, 1, 1}, /* PyObject cname: __pyx_n_u_input_price_series_names_2 */
+  {__pyx_k_integer, sizeof(__pyx_k_integer), 0, 1, 1}, /* PyObject cname: __pyx_n_u_integer */
+  {__pyx_k_integer_values_are_100_0_or_100, sizeof(__pyx_k_integer_values_are_100_0_or_100), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_integer_values_are_100_0_or_100 */
+  {__pyx_k_is_coroutine, sizeof(__pyx_k_is_coroutine), 0, 1, 1}, /* PyObject cname: __pyx_n_u_is_coroutine */
+  {__pyx_k_is_empty, sizeof(__pyx_k_is_empty), 0, 1, 1}, /* PyObject cname: __pyx_n_u_is_empty */
+  {__pyx_k_items, sizeof(__pyx_k_items), 0, 1, 1}, /* PyObject cname: __pyx_n_u_items */
+  {__pyx_k_key, sizeof(__pyx_k_key), 0, 1, 1}, /* PyObject cname: __pyx_n_u_key */
+  {__pyx_k_keys, sizeof(__pyx_k_keys), 0, 1, 1}, /* PyObject cname: __pyx_n_u_keys */
+  {__pyx_k_kwargs, sizeof(__pyx_k_kwargs), 0, 1, 1}, /* PyObject cname: __pyx_n_u_kwargs */
+  {__pyx_k_length, sizeof(__pyx_k_length), 0, 1, 1}, /* PyObject cname: __pyx_n_u_length */
+  {__pyx_k_local, sizeof(__pyx_k_local), 0, 1, 1}, /* PyObject cname: __pyx_n_u_local */
+  {__pyx_k_local_2, sizeof(__pyx_k_local_2), 0, 1, 1}, /* PyObject cname: __pyx_n_u_local_2 */
+  {__pyx_k_log, sizeof(__pyx_k_log), 0, 1, 1}, /* PyObject cname: __pyx_n_u_log */
+  {__pyx_k_lookback, sizeof(__pyx_k_lookback), 0, 1, 1}, /* PyObject cname: __pyx_n_u_lookback */
+  {__pyx_k_lookup, sizeof(__pyx_k_lookup), 0, 1, 1}, /* PyObject cname: __pyx_n_u_lookup */
+  {__pyx_k_low, sizeof(__pyx_k_low), 0, 1, 1}, /* PyObject cname: __pyx_n_u_low */
+  {__pyx_k_low_data, sizeof(__pyx_k_low_data), 0, 1, 1}, /* PyObject cname: __pyx_n_u_low_data */
+  {__pyx_k_lower, sizeof(__pyx_k_lower), 0, 1, 1}, /* PyObject cname: __pyx_n_u_lower */
+  {__pyx_k_main, sizeof(__pyx_k_main), 0, 1, 1}, /* PyObject cname: __pyx_n_u_main */
+  {__pyx_k_math, sizeof(__pyx_k_math), 0, 1, 1}, /* PyObject cname: __pyx_n_u_math */
+  {__pyx_k_matype, sizeof(__pyx_k_matype), 0, 1, 1}, /* PyObject cname: __pyx_n_u_matype */
+  {__pyx_k_max, sizeof(__pyx_k_max), 0, 1, 1}, /* PyObject cname: __pyx_n_u_max */
+  {__pyx_k_max_int, sizeof(__pyx_k_max_int), 0, 1, 1}, /* PyObject cname: __pyx_n_u_max_int */
+  {__pyx_k_maximum, sizeof(__pyx_k_maximum), 0, 1, 1}, /* PyObject cname: __pyx_n_u_maximum */
+  {__pyx_k_maxperiod, sizeof(__pyx_k_maxperiod), 0, 1, 1}, /* PyObject cname: __pyx_n_u_maxperiod */
+  {__pyx_k_metaclass, sizeof(__pyx_k_metaclass), 0, 1, 1}, /* PyObject cname: __pyx_n_u_metaclass */
+  {__pyx_k_min, sizeof(__pyx_k_min), 0, 1, 1}, /* PyObject cname: __pyx_n_u_min */
+  {__pyx_k_min_int, sizeof(__pyx_k_min_int), 0, 1, 1}, /* PyObject cname: __pyx_n_u_min_int */
+  {__pyx_k_minperiod, sizeof(__pyx_k_minperiod), 0, 1, 1}, /* PyObject cname: __pyx_n_u_minperiod */
+  {__pyx_k_missing, sizeof(__pyx_k_missing), 0, 1, 1}, /* PyObject cname: __pyx_n_u_missing */
+  {__pyx_k_missing_keys, sizeof(__pyx_k_missing_keys), 0, 1, 1}, /* PyObject cname: __pyx_n_u_missing_keys */
+  {__pyx_k_module, sizeof(__pyx_k_module), 0, 1, 1}, /* PyObject cname: __pyx_n_u_module */
+  {__pyx_k_mro_entries, sizeof(__pyx_k_mro_entries), 0, 1, 1}, /* PyObject cname: __pyx_n_u_mro_entries */
+  {__pyx_k_msg, sizeof(__pyx_k_msg), 0, 1, 1}, /* PyObject cname: __pyx_n_u_msg */
+  {__pyx_k_n, sizeof(__pyx_k_n), 0, 1, 1}, /* PyObject cname: __pyx_n_u_n */
+  {__pyx_k_name, sizeof(__pyx_k_name), 0, 1, 1}, /* PyObject cname: __pyx_n_u_name */
+  {__pyx_k_name_2, sizeof(__pyx_k_name_2), 0, 1, 1}, /* PyObject cname: __pyx_n_u_name_2 */
+  {__pyx_k_nan, sizeof(__pyx_k_nan), 0, 1, 1}, /* PyObject cname: __pyx_n_u_nan */
+  {__pyx_k_nbdev, sizeof(__pyx_k_nbdev), 0, 1, 1}, /* PyObject cname: __pyx_n_u_nbdev */
+  {__pyx_k_nbdevdn, sizeof(__pyx_k_nbdevdn), 0, 1, 1}, /* PyObject cname: __pyx_n_u_nbdevdn */
+  {__pyx_k_nbdevup, sizeof(__pyx_k_nbdevup), 0, 1, 1}, /* PyObject cname: __pyx_n_u_nbdevup */
+  {__pyx_k_no_existing_input_arrays, sizeof(__pyx_k_no_existing_input_arrays), 0, 1, 1}, /* PyObject cname: __pyx_n_u_no_existing_input_arrays */
+  {__pyx_k_num_inputs, sizeof(__pyx_k_num_inputs), 0, 1, 1}, /* PyObject cname: __pyx_n_u_num_inputs */
+  {__pyx_k_num_opt_inputs, sizeof(__pyx_k_num_opt_inputs), 0, 1, 1}, /* PyObject cname: __pyx_n_u_num_opt_inputs */
+  {__pyx_k_num_outputs, sizeof(__pyx_k_num_outputs), 0, 1, 1}, /* PyObject cname: __pyx_n_u_num_outputs */
+  {__pyx_k_numpy, sizeof(__pyx_k_numpy), 0, 1, 1}, /* PyObject cname: __pyx_n_u_numpy */
+  {__pyx_k_numpy__core_multiarray_failed_to, sizeof(__pyx_k_numpy__core_multiarray_failed_to), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_numpy__core_multiarray_failed_to */
+  {__pyx_k_numpy__core_umath_failed_to_impo, sizeof(__pyx_k_numpy__core_umath_failed_to_impo), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_numpy__core_umath_failed_to_impo */
+  {__pyx_k_object, sizeof(__pyx_k_object), 0, 1, 1}, /* PyObject cname: __pyx_n_u_object */
+  {__pyx_k_offsetonreverse, sizeof(__pyx_k_offsetonreverse), 0, 1, 1}, /* PyObject cname: __pyx_n_u_offsetonreverse */
+  {__pyx_k_open, sizeof(__pyx_k_open), 0, 1, 1}, /* PyObject cname: __pyx_n_u_open */
+  {__pyx_k_openInterest, sizeof(__pyx_k_openInterest), 0, 1, 1}, /* PyObject cname: __pyx_n_u_openInterest */
+  {__pyx_k_open_data, sizeof(__pyx_k_open_data), 0, 1, 1}, /* PyObject cname: __pyx_n_u_open_data */
+  {__pyx_k_optIn, sizeof(__pyx_k_optIn), 0, 1, 1}, /* PyObject cname: __pyx_n_u_optIn */
+  {__pyx_k_opt_input, sizeof(__pyx_k_opt_input), 0, 1, 1}, /* PyObject cname: __pyx_n_u_opt_input */
+  {__pyx_k_opt_input_values, sizeof(__pyx_k_opt_input_values), 0, 1, 1}, /* PyObject cname: __pyx_n_u_opt_input_values */
+  {__pyx_k_opt_inputs, sizeof(__pyx_k_opt_inputs), 0, 1, 1}, /* PyObject cname: __pyx_n_u_opt_inputs */
+  {__pyx_k_ordereddict, sizeof(__pyx_k_ordereddict), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ordereddict */
+  {__pyx_k_out, sizeof(__pyx_k_out), 0, 1, 1}, /* PyObject cname: __pyx_n_u_out */
+  {__pyx_k_outaroondown, sizeof(__pyx_k_outaroondown), 0, 1, 1}, /* PyObject cname: __pyx_n_u_outaroondown */
+  {__pyx_k_outaroonup, sizeof(__pyx_k_outaroonup), 0, 1, 1}, /* PyObject cname: __pyx_n_u_outaroonup */
+  {__pyx_k_outbegidx, sizeof(__pyx_k_outbegidx), 0, 1, 1}, /* PyObject cname: __pyx_n_u_outbegidx */
+  {__pyx_k_outfama, sizeof(__pyx_k_outfama), 0, 1, 1}, /* PyObject cname: __pyx_n_u_outfama */
+  {__pyx_k_outfastd, sizeof(__pyx_k_outfastd), 0, 1, 1}, /* PyObject cname: __pyx_n_u_outfastd */
+  {__pyx_k_outfastk, sizeof(__pyx_k_outfastk), 0, 1, 1}, /* PyObject cname: __pyx_n_u_outfastk */
+  {__pyx_k_outinphase, sizeof(__pyx_k_outinphase), 0, 1, 1}, /* PyObject cname: __pyx_n_u_outinphase */
+  {__pyx_k_outinteger, sizeof(__pyx_k_outinteger), 0, 1, 1}, /* PyObject cname: __pyx_n_u_outinteger */
+  {__pyx_k_outinteger_data, sizeof(__pyx_k_outinteger_data), 0, 1, 1}, /* PyObject cname: __pyx_n_u_outinteger_data */
+  {__pyx_k_outleadsine, sizeof(__pyx_k_outleadsine), 0, 1, 1}, /* PyObject cname: __pyx_n_u_outleadsine */
+  {__pyx_k_outmacd, sizeof(__pyx_k_outmacd), 0, 1, 1}, /* PyObject cname: __pyx_n_u_outmacd */
+  {__pyx_k_outmacdhist, sizeof(__pyx_k_outmacdhist), 0, 1, 1}, /* PyObject cname: __pyx_n_u_outmacdhist */
+  {__pyx_k_outmacdsignal, sizeof(__pyx_k_outmacdsignal), 0, 1, 1}, /* PyObject cname: __pyx_n_u_outmacdsignal */
+  {__pyx_k_outmama, sizeof(__pyx_k_outmama), 0, 1, 1}, /* PyObject cname: __pyx_n_u_outmama */
+  {__pyx_k_outmax, sizeof(__pyx_k_outmax), 0, 1, 1}, /* PyObject cname: __pyx_n_u_outmax */
+  {__pyx_k_outmaxidx, sizeof(__pyx_k_outmaxidx), 0, 1, 1}, /* PyObject cname: __pyx_n_u_outmaxidx */
+  {__pyx_k_outmaxidx_data, sizeof(__pyx_k_outmaxidx_data), 0, 1, 1}, /* PyObject cname: __pyx_n_u_outmaxidx_data */
+  {__pyx_k_outmin, sizeof(__pyx_k_outmin), 0, 1, 1}, /* PyObject cname: __pyx_n_u_outmin */
+  {__pyx_k_outminidx, sizeof(__pyx_k_outminidx), 0, 1, 1}, /* PyObject cname: __pyx_n_u_outminidx */
+  {__pyx_k_outminidx_data, sizeof(__pyx_k_outminidx_data), 0, 1, 1}, /* PyObject cname: __pyx_n_u_outminidx_data */
+  {__pyx_k_outnbelement, sizeof(__pyx_k_outnbelement), 0, 1, 1}, /* PyObject cname: __pyx_n_u_outnbelement */
+  {__pyx_k_output, sizeof(__pyx_k_output), 0, 1, 1}, /* PyObject cname: __pyx_n_u_output */
+  {__pyx_k_output_flags, sizeof(__pyx_k_output_flags), 0, 1, 1}, /* PyObject cname: __pyx_n_u_output_flags */
+  {__pyx_k_output_name, sizeof(__pyx_k_output_name), 0, 1, 1}, /* PyObject cname: __pyx_n_u_output_name */
+  {__pyx_k_output_names, sizeof(__pyx_k_output_names), 0, 1, 1}, /* PyObject cname: __pyx_n_u_output_names */
+  {__pyx_k_outputs, sizeof(__pyx_k_outputs), 0, 1, 1}, /* PyObject cname: __pyx_n_u_outputs */
+  {__pyx_k_outputs_valid, sizeof(__pyx_k_outputs_valid), 0, 1, 1}, /* PyObject cname: __pyx_n_u_outputs_valid */
+  {__pyx_k_outquadrature, sizeof(__pyx_k_outquadrature), 0, 1, 1}, /* PyObject cname: __pyx_n_u_outquadrature */
+  {__pyx_k_outreal, sizeof(__pyx_k_outreal), 0, 1, 1}, /* PyObject cname: __pyx_n_u_outreal */
+  {__pyx_k_outreallowerband, sizeof(__pyx_k_outreallowerband), 0, 1, 1}, /* PyObject cname: __pyx_n_u_outreallowerband */
+  {__pyx_k_outrealmiddleband, sizeof(__pyx_k_outrealmiddleband), 0, 1, 1}, /* PyObject cname: __pyx_n_u_outrealmiddleband */
+  {__pyx_k_outrealupperband, sizeof(__pyx_k_outrealupperband), 0, 1, 1}, /* PyObject cname: __pyx_n_u_outrealupperband */
+  {__pyx_k_outsine, sizeof(__pyx_k_outsine), 0, 1, 1}, /* PyObject cname: __pyx_n_u_outsine */
+  {__pyx_k_outslowd, sizeof(__pyx_k_outslowd), 0, 1, 1}, /* PyObject cname: __pyx_n_u_outslowd */
+  {__pyx_k_outslowk, sizeof(__pyx_k_outslowk), 0, 1, 1}, /* PyObject cname: __pyx_n_u_outslowk */
+  {__pyx_k_pandas, sizeof(__pyx_k_pandas), 0, 1, 1}, /* PyObject cname: __pyx_n_u_pandas */
+  {__pyx_k_param, sizeof(__pyx_k_param), 0, 1, 1}, /* PyObject cname: __pyx_n_u_param */
+  {__pyx_k_param_name, sizeof(__pyx_k_param_name), 0, 1, 1}, /* PyObject cname: __pyx_n_u_param_name */
+  {__pyx_k_parameters, sizeof(__pyx_k_parameters), 0, 1, 1}, /* PyObject cname: __pyx_n_u_parameters */
+  {__pyx_k_params, sizeof(__pyx_k_params), 0, 1, 1}, /* PyObject cname: __pyx_n_u_params */
+  {__pyx_k_penetration, sizeof(__pyx_k_penetration), 0, 1, 1}, /* PyObject cname: __pyx_n_u_penetration */
+  {__pyx_k_period, sizeof(__pyx_k_period), 0, 1, 1}, /* PyObject cname: __pyx_n_u_period */
+  {__pyx_k_periods, sizeof(__pyx_k_periods), 0, 1, 1}, /* PyObject cname: __pyx_n_u_periods */
+  {__pyx_k_periods_data, sizeof(__pyx_k_periods_data), 0, 1, 1}, /* PyObject cname: __pyx_n_u_periods_data */
+  {__pyx_k_polars, sizeof(__pyx_k_polars), 0, 1, 1}, /* PyObject cname: __pyx_n_u_polars */
+  {__pyx_k_pop, sizeof(__pyx_k_pop), 0, 1, 1}, /* PyObject cname: __pyx_n_u_pop */
+  {__pyx_k_prepare, sizeof(__pyx_k_prepare), 0, 1, 1}, /* PyObject cname: __pyx_n_u_prepare */
+  {__pyx_k_price, sizeof(__pyx_k_price), 0, 1, 1}, /* PyObject cname: __pyx_n_u_price */
+  {__pyx_k_price0, sizeof(__pyx_k_price0), 0, 1, 1}, /* PyObject cname: __pyx_n_u_price0 */
+  {__pyx_k_price1, sizeof(__pyx_k_price1), 0, 1, 1}, /* PyObject cname: __pyx_n_u_price1 */
+  {__pyx_k_price_series, sizeof(__pyx_k_price_series), 0, 1, 1}, /* PyObject cname: __pyx_n_u_price_series */
+  {__pyx_k_price_series_name_values, sizeof(__pyx_k_price_series_name_values), 0, 1, 1}, /* PyObject cname: __pyx_n_u_price_series_name_values */
+  {__pyx_k_prices, sizeof(__pyx_k_prices), 0, 1, 1}, /* PyObject cname: __pyx_n_u_prices */
+  {__pyx_k_property, sizeof(__pyx_k_property), 0, 1, 1}, /* PyObject cname: __pyx_n_u_property */
+  {__pyx_k_qualname, sizeof(__pyx_k_qualname), 0, 1, 1}, /* PyObject cname: __pyx_n_u_qualname */
+  {__pyx_k_range, sizeof(__pyx_k_range), 0, 1, 1}, /* PyObject cname: __pyx_n_u_range */
+  {__pyx_k_rangetype, sizeof(__pyx_k_rangetype), 0, 1, 1}, /* PyObject cname: __pyx_n_u_rangetype */
+  {__pyx_k_real, sizeof(__pyx_k_real), 0, 1, 1}, /* PyObject cname: __pyx_n_u_real */
+  {__pyx_k_real0, sizeof(__pyx_k_real0), 0, 1, 1}, /* PyObject cname: __pyx_n_u_real0 */
+  {__pyx_k_real0_data, sizeof(__pyx_k_real0_data), 0, 1, 1}, /* PyObject cname: __pyx_n_u_real0_data */
+  {__pyx_k_real1, sizeof(__pyx_k_real1), 0, 1, 1}, /* PyObject cname: __pyx_n_u_real1 */
+  {__pyx_k_real1_data, sizeof(__pyx_k_real1_data), 0, 1, 1}, /* PyObject cname: __pyx_n_u_real1_data */
+  {__pyx_k_real_data, sizeof(__pyx_k_real_data), 0, 1, 1}, /* PyObject cname: __pyx_n_u_real_data */
+  {__pyx_k_replace, sizeof(__pyx_k_replace), 0, 1, 1}, /* PyObject cname: __pyx_n_u_replace */
+  {__pyx_k_repr, sizeof(__pyx_k_repr), 0, 1, 1}, /* PyObject cname: __pyx_n_u_repr */
+  {__pyx_k_results, sizeof(__pyx_k_results), 0, 1, 1}, /* PyObject cname: __pyx_n_u_results */
+  {__pyx_k_ret, sizeof(__pyx_k_ret), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ret */
+  {__pyx_k_retCode, sizeof(__pyx_k_retCode), 0, 1, 1}, /* PyObject cname: __pyx_n_u_retCode */
+  {__pyx_k_ret_code, sizeof(__pyx_k_ret_code), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ret_code */
+  {__pyx_k_run, sizeof(__pyx_k_run), 0, 1, 1}, /* PyObject cname: __pyx_n_u_run */
+  {__pyx_k_s, sizeof(__pyx_k_s), 0, 1, 1}, /* PyObject cname: __pyx_n_u_s */
+  {__pyx_k_s_2, sizeof(__pyx_k_s_2), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_s_2 */
+  {__pyx_k_s_3, sizeof(__pyx_k_s_3), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_s_3 */
+  {__pyx_k_s_4, sizeof(__pyx_k_s_4), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_s_4 */
+  {__pyx_k_schema, sizeof(__pyx_k_schema), 0, 1, 1}, /* PyObject cname: __pyx_n_u_schema */
+  {__pyx_k_self, sizeof(__pyx_k_self), 0, 1, 1}, /* PyObject cname: __pyx_n_u_self */
+  {__pyx_k_series, sizeof(__pyx_k_series), 0, 1, 1}, /* PyObject cname: __pyx_n_u_series */
+  {__pyx_k_set_function_args, sizeof(__pyx_k_set_function_args), 0, 1, 1}, /* PyObject cname: __pyx_n_u_set_function_args */
+  {__pyx_k_set_input_arrays, sizeof(__pyx_k_set_input_arrays), 0, 1, 1}, /* PyObject cname: __pyx_n_u_set_input_arrays */
+  {__pyx_k_set_input_names, sizeof(__pyx_k_set_input_names), 0, 1, 1}, /* PyObject cname: __pyx_n_u_set_input_names */
+  {__pyx_k_set_name, sizeof(__pyx_k_set_name), 0, 1, 1}, /* PyObject cname: __pyx_n_u_set_name */
+  {__pyx_k_set_parameters, sizeof(__pyx_k_set_parameters), 0, 1, 1}, /* PyObject cname: __pyx_n_u_set_parameters */
+  {__pyx_k_settingtype, sizeof(__pyx_k_settingtype), 0, 1, 1}, /* PyObject cname: __pyx_n_u_settingtype */
+  {__pyx_k_signalmatype, sizeof(__pyx_k_signalmatype), 0, 1, 1}, /* PyObject cname: __pyx_n_u_signalmatype */
+  {__pyx_k_signalperiod, sizeof(__pyx_k_signalperiod), 0, 1, 1}, /* PyObject cname: __pyx_n_u_signalperiod */
+  {__pyx_k_skip_first, sizeof(__pyx_k_skip_first), 0, 1, 1}, /* PyObject cname: __pyx_n_u_skip_first */
+  {__pyx_k_slowd_matype, sizeof(__pyx_k_slowd_matype), 0, 1, 1}, /* PyObject cname: __pyx_n_u_slowd_matype */
+  {__pyx_k_slowd_period, sizeof(__pyx_k_slowd_period), 0, 1, 1}, /* PyObject cname: __pyx_n_u_slowd_period */
+  {__pyx_k_slowk_matype, sizeof(__pyx_k_slowk_matype), 0, 1, 1}, /* PyObject cname: __pyx_n_u_slowk_matype */
+  {__pyx_k_slowk_period, sizeof(__pyx_k_slowk_period), 0, 1, 1}, /* PyObject cname: __pyx_n_u_slowk_period */
+  {__pyx_k_slowlimit, sizeof(__pyx_k_slowlimit), 0, 1, 1}, /* PyObject cname: __pyx_n_u_slowlimit */
+  {__pyx_k_slowmatype, sizeof(__pyx_k_slowmatype), 0, 1, 1}, /* PyObject cname: __pyx_n_u_slowmatype */
+  {__pyx_k_slowperiod, sizeof(__pyx_k_slowperiod), 0, 1, 1}, /* PyObject cname: __pyx_n_u_slowperiod */
+  {__pyx_k_spec, sizeof(__pyx_k_spec), 0, 1, 1}, /* PyObject cname: __pyx_n_u_spec */
+  {__pyx_k_startvalue, sizeof(__pyx_k_startvalue), 0, 1, 1}, /* PyObject cname: __pyx_n_u_startvalue */
+  {__pyx_k_str, sizeof(__pyx_k_str), 0, 1, 1}, /* PyObject cname: __pyx_n_u_str */
+  {__pyx_k_str2bytes, sizeof(__pyx_k_str2bytes), 0, 1, 1}, /* PyObject cname: __pyx_n_u_str2bytes */
+  {__pyx_k_stream_ACCBANDS, sizeof(__pyx_k_stream_ACCBANDS), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_ACCBANDS */
+  {__pyx_k_stream_ACOS, sizeof(__pyx_k_stream_ACOS), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_ACOS */
+  {__pyx_k_stream_AD, sizeof(__pyx_k_stream_AD), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_AD */
+  {__pyx_k_stream_ADD, sizeof(__pyx_k_stream_ADD), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_ADD */
+  {__pyx_k_stream_ADOSC, sizeof(__pyx_k_stream_ADOSC), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_ADOSC */
+  {__pyx_k_stream_ADX, sizeof(__pyx_k_stream_ADX), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_ADX */
+  {__pyx_k_stream_ADXR, sizeof(__pyx_k_stream_ADXR), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_ADXR */
+  {__pyx_k_stream_APO, sizeof(__pyx_k_stream_APO), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_APO */
+  {__pyx_k_stream_AROON, sizeof(__pyx_k_stream_AROON), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_AROON */
+  {__pyx_k_stream_AROONOSC, sizeof(__pyx_k_stream_AROONOSC), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_AROONOSC */
+  {__pyx_k_stream_ASIN, sizeof(__pyx_k_stream_ASIN), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_ASIN */
+  {__pyx_k_stream_ATAN, sizeof(__pyx_k_stream_ATAN), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_ATAN */
+  {__pyx_k_stream_ATR, sizeof(__pyx_k_stream_ATR), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_ATR */
+  {__pyx_k_stream_AVGDEV, sizeof(__pyx_k_stream_AVGDEV), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_AVGDEV */
+  {__pyx_k_stream_AVGPRICE, sizeof(__pyx_k_stream_AVGPRICE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_AVGPRICE */
+  {__pyx_k_stream_BBANDS, sizeof(__pyx_k_stream_BBANDS), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_BBANDS */
+  {__pyx_k_stream_BETA, sizeof(__pyx_k_stream_BETA), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_BETA */
+  {__pyx_k_stream_BOP, sizeof(__pyx_k_stream_BOP), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_BOP */
+  {__pyx_k_stream_CCI, sizeof(__pyx_k_stream_CCI), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CCI */
+  {__pyx_k_stream_CDL2CROWS, sizeof(__pyx_k_stream_CDL2CROWS), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDL2CROWS */
+  {__pyx_k_stream_CDL3BLACKCROWS, sizeof(__pyx_k_stream_CDL3BLACKCROWS), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDL3BLACKCROWS */
+  {__pyx_k_stream_CDL3INSIDE, sizeof(__pyx_k_stream_CDL3INSIDE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDL3INSIDE */
+  {__pyx_k_stream_CDL3LINESTRIKE, sizeof(__pyx_k_stream_CDL3LINESTRIKE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDL3LINESTRIKE */
+  {__pyx_k_stream_CDL3OUTSIDE, sizeof(__pyx_k_stream_CDL3OUTSIDE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDL3OUTSIDE */
+  {__pyx_k_stream_CDL3STARSINSOUTH, sizeof(__pyx_k_stream_CDL3STARSINSOUTH), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDL3STARSINSOUTH */
+  {__pyx_k_stream_CDL3WHITESOLDIERS, sizeof(__pyx_k_stream_CDL3WHITESOLDIERS), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDL3WHITESOLDIERS */
+  {__pyx_k_stream_CDLABANDONEDBABY, sizeof(__pyx_k_stream_CDLABANDONEDBABY), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLABANDONEDBABY */
+  {__pyx_k_stream_CDLADVANCEBLOCK, sizeof(__pyx_k_stream_CDLADVANCEBLOCK), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLADVANCEBLOCK */
+  {__pyx_k_stream_CDLBELTHOLD, sizeof(__pyx_k_stream_CDLBELTHOLD), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLBELTHOLD */
+  {__pyx_k_stream_CDLBREAKAWAY, sizeof(__pyx_k_stream_CDLBREAKAWAY), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLBREAKAWAY */
+  {__pyx_k_stream_CDLCLOSINGMARUBOZU, sizeof(__pyx_k_stream_CDLCLOSINGMARUBOZU), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLCLOSINGMARUBOZU */
+  {__pyx_k_stream_CDLCONCEALBABYSWALL, sizeof(__pyx_k_stream_CDLCONCEALBABYSWALL), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLCONCEALBABYSWALL */
+  {__pyx_k_stream_CDLCOUNTERATTACK, sizeof(__pyx_k_stream_CDLCOUNTERATTACK), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLCOUNTERATTACK */
+  {__pyx_k_stream_CDLDARKCLOUDCOVER, sizeof(__pyx_k_stream_CDLDARKCLOUDCOVER), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLDARKCLOUDCOVER */
+  {__pyx_k_stream_CDLDOJI, sizeof(__pyx_k_stream_CDLDOJI), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLDOJI */
+  {__pyx_k_stream_CDLDOJISTAR, sizeof(__pyx_k_stream_CDLDOJISTAR), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLDOJISTAR */
+  {__pyx_k_stream_CDLDRAGONFLYDOJI, sizeof(__pyx_k_stream_CDLDRAGONFLYDOJI), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLDRAGONFLYDOJI */
+  {__pyx_k_stream_CDLENGULFING, sizeof(__pyx_k_stream_CDLENGULFING), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLENGULFING */
+  {__pyx_k_stream_CDLEVENINGDOJISTAR, sizeof(__pyx_k_stream_CDLEVENINGDOJISTAR), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLEVENINGDOJISTAR */
+  {__pyx_k_stream_CDLEVENINGSTAR, sizeof(__pyx_k_stream_CDLEVENINGSTAR), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLEVENINGSTAR */
+  {__pyx_k_stream_CDLGAPSIDESIDEWHITE, sizeof(__pyx_k_stream_CDLGAPSIDESIDEWHITE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLGAPSIDESIDEWHITE */
+  {__pyx_k_stream_CDLGRAVESTONEDOJI, sizeof(__pyx_k_stream_CDLGRAVESTONEDOJI), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLGRAVESTONEDOJI */
+  {__pyx_k_stream_CDLHAMMER, sizeof(__pyx_k_stream_CDLHAMMER), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLHAMMER */
+  {__pyx_k_stream_CDLHANGINGMAN, sizeof(__pyx_k_stream_CDLHANGINGMAN), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLHANGINGMAN */
+  {__pyx_k_stream_CDLHARAMI, sizeof(__pyx_k_stream_CDLHARAMI), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLHARAMI */
+  {__pyx_k_stream_CDLHARAMICROSS, sizeof(__pyx_k_stream_CDLHARAMICROSS), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLHARAMICROSS */
+  {__pyx_k_stream_CDLHIGHWAVE, sizeof(__pyx_k_stream_CDLHIGHWAVE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLHIGHWAVE */
+  {__pyx_k_stream_CDLHIKKAKE, sizeof(__pyx_k_stream_CDLHIKKAKE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLHIKKAKE */
+  {__pyx_k_stream_CDLHIKKAKEMOD, sizeof(__pyx_k_stream_CDLHIKKAKEMOD), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLHIKKAKEMOD */
+  {__pyx_k_stream_CDLHOMINGPIGEON, sizeof(__pyx_k_stream_CDLHOMINGPIGEON), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLHOMINGPIGEON */
+  {__pyx_k_stream_CDLIDENTICAL3CROWS, sizeof(__pyx_k_stream_CDLIDENTICAL3CROWS), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLIDENTICAL3CROWS */
+  {__pyx_k_stream_CDLINNECK, sizeof(__pyx_k_stream_CDLINNECK), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLINNECK */
+  {__pyx_k_stream_CDLINVERTEDHAMMER, sizeof(__pyx_k_stream_CDLINVERTEDHAMMER), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLINVERTEDHAMMER */
+  {__pyx_k_stream_CDLKICKING, sizeof(__pyx_k_stream_CDLKICKING), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLKICKING */
+  {__pyx_k_stream_CDLKICKINGBYLENGTH, sizeof(__pyx_k_stream_CDLKICKINGBYLENGTH), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLKICKINGBYLENGTH */
+  {__pyx_k_stream_CDLLADDERBOTTOM, sizeof(__pyx_k_stream_CDLLADDERBOTTOM), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLLADDERBOTTOM */
+  {__pyx_k_stream_CDLLONGLEGGEDDOJI, sizeof(__pyx_k_stream_CDLLONGLEGGEDDOJI), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLLONGLEGGEDDOJI */
+  {__pyx_k_stream_CDLLONGLINE, sizeof(__pyx_k_stream_CDLLONGLINE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLLONGLINE */
+  {__pyx_k_stream_CDLMARUBOZU, sizeof(__pyx_k_stream_CDLMARUBOZU), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLMARUBOZU */
+  {__pyx_k_stream_CDLMATCHINGLOW, sizeof(__pyx_k_stream_CDLMATCHINGLOW), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLMATCHINGLOW */
+  {__pyx_k_stream_CDLMATHOLD, sizeof(__pyx_k_stream_CDLMATHOLD), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLMATHOLD */
+  {__pyx_k_stream_CDLMORNINGDOJISTAR, sizeof(__pyx_k_stream_CDLMORNINGDOJISTAR), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLMORNINGDOJISTAR */
+  {__pyx_k_stream_CDLMORNINGSTAR, sizeof(__pyx_k_stream_CDLMORNINGSTAR), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLMORNINGSTAR */
+  {__pyx_k_stream_CDLONNECK, sizeof(__pyx_k_stream_CDLONNECK), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLONNECK */
+  {__pyx_k_stream_CDLPIERCING, sizeof(__pyx_k_stream_CDLPIERCING), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLPIERCING */
+  {__pyx_k_stream_CDLRICKSHAWMAN, sizeof(__pyx_k_stream_CDLRICKSHAWMAN), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLRICKSHAWMAN */
+  {__pyx_k_stream_CDLRISEFALL3METHODS, sizeof(__pyx_k_stream_CDLRISEFALL3METHODS), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLRISEFALL3METHODS */
+  {__pyx_k_stream_CDLSEPARATINGLINES, sizeof(__pyx_k_stream_CDLSEPARATINGLINES), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLSEPARATINGLINES */
+  {__pyx_k_stream_CDLSHOOTINGSTAR, sizeof(__pyx_k_stream_CDLSHOOTINGSTAR), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLSHOOTINGSTAR */
+  {__pyx_k_stream_CDLSHORTLINE, sizeof(__pyx_k_stream_CDLSHORTLINE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLSHORTLINE */
+  {__pyx_k_stream_CDLSPINNINGTOP, sizeof(__pyx_k_stream_CDLSPINNINGTOP), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLSPINNINGTOP */
+  {__pyx_k_stream_CDLSTALLEDPATTERN, sizeof(__pyx_k_stream_CDLSTALLEDPATTERN), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLSTALLEDPATTERN */
+  {__pyx_k_stream_CDLSTICKSANDWICH, sizeof(__pyx_k_stream_CDLSTICKSANDWICH), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLSTICKSANDWICH */
+  {__pyx_k_stream_CDLTAKURI, sizeof(__pyx_k_stream_CDLTAKURI), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLTAKURI */
+  {__pyx_k_stream_CDLTASUKIGAP, sizeof(__pyx_k_stream_CDLTASUKIGAP), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLTASUKIGAP */
+  {__pyx_k_stream_CDLTHRUSTING, sizeof(__pyx_k_stream_CDLTHRUSTING), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLTHRUSTING */
+  {__pyx_k_stream_CDLTRISTAR, sizeof(__pyx_k_stream_CDLTRISTAR), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLTRISTAR */
+  {__pyx_k_stream_CDLUNIQUE3RIVER, sizeof(__pyx_k_stream_CDLUNIQUE3RIVER), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLUNIQUE3RIVER */
+  {__pyx_k_stream_CDLUPSIDEGAP2CROWS, sizeof(__pyx_k_stream_CDLUPSIDEGAP2CROWS), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLUPSIDEGAP2CROWS */
+  {__pyx_k_stream_CDLXSIDEGAP3METHODS, sizeof(__pyx_k_stream_CDLXSIDEGAP3METHODS), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CDLXSIDEGAP3METHODS */
+  {__pyx_k_stream_CEIL, sizeof(__pyx_k_stream_CEIL), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CEIL */
+  {__pyx_k_stream_CMO, sizeof(__pyx_k_stream_CMO), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CMO */
+  {__pyx_k_stream_CORREL, sizeof(__pyx_k_stream_CORREL), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_CORREL */
+  {__pyx_k_stream_COS, sizeof(__pyx_k_stream_COS), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_COS */
+  {__pyx_k_stream_COSH, sizeof(__pyx_k_stream_COSH), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_COSH */
+  {__pyx_k_stream_DEMA, sizeof(__pyx_k_stream_DEMA), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_DEMA */
+  {__pyx_k_stream_DIV, sizeof(__pyx_k_stream_DIV), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_DIV */
+  {__pyx_k_stream_DX, sizeof(__pyx_k_stream_DX), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_DX */
+  {__pyx_k_stream_EMA, sizeof(__pyx_k_stream_EMA), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_EMA */
+  {__pyx_k_stream_EXP, sizeof(__pyx_k_stream_EXP), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_EXP */
+  {__pyx_k_stream_FLOOR, sizeof(__pyx_k_stream_FLOOR), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_FLOOR */
+  {__pyx_k_stream_HT_DCPERIOD, sizeof(__pyx_k_stream_HT_DCPERIOD), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_HT_DCPERIOD */
+  {__pyx_k_stream_HT_DCPHASE, sizeof(__pyx_k_stream_HT_DCPHASE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_HT_DCPHASE */
+  {__pyx_k_stream_HT_PHASOR, sizeof(__pyx_k_stream_HT_PHASOR), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_HT_PHASOR */
+  {__pyx_k_stream_HT_SINE, sizeof(__pyx_k_stream_HT_SINE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_HT_SINE */
+  {__pyx_k_stream_HT_TRENDLINE, sizeof(__pyx_k_stream_HT_TRENDLINE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_HT_TRENDLINE */
+  {__pyx_k_stream_HT_TRENDMODE, sizeof(__pyx_k_stream_HT_TRENDMODE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_HT_TRENDMODE */
+  {__pyx_k_stream_IMI, sizeof(__pyx_k_stream_IMI), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_IMI */
+  {__pyx_k_stream_KAMA, sizeof(__pyx_k_stream_KAMA), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_KAMA */
+  {__pyx_k_stream_LINEARREG, sizeof(__pyx_k_stream_LINEARREG), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_LINEARREG */
+  {__pyx_k_stream_LINEARREG_ANGLE, sizeof(__pyx_k_stream_LINEARREG_ANGLE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_LINEARREG_ANGLE */
+  {__pyx_k_stream_LINEARREG_INTERCEPT, sizeof(__pyx_k_stream_LINEARREG_INTERCEPT), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_LINEARREG_INTERCEPT */
+  {__pyx_k_stream_LINEARREG_SLOPE, sizeof(__pyx_k_stream_LINEARREG_SLOPE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_LINEARREG_SLOPE */
+  {__pyx_k_stream_LN, sizeof(__pyx_k_stream_LN), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_LN */
+  {__pyx_k_stream_LOG10, sizeof(__pyx_k_stream_LOG10), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_LOG10 */
+  {__pyx_k_stream_MA, sizeof(__pyx_k_stream_MA), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_MA */
+  {__pyx_k_stream_MACD, sizeof(__pyx_k_stream_MACD), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_MACD */
+  {__pyx_k_stream_MACDEXT, sizeof(__pyx_k_stream_MACDEXT), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_MACDEXT */
+  {__pyx_k_stream_MACDFIX, sizeof(__pyx_k_stream_MACDFIX), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_MACDFIX */
+  {__pyx_k_stream_MAMA, sizeof(__pyx_k_stream_MAMA), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_MAMA */
+  {__pyx_k_stream_MAVP, sizeof(__pyx_k_stream_MAVP), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_MAVP */
+  {__pyx_k_stream_MAX, sizeof(__pyx_k_stream_MAX), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_MAX */
+  {__pyx_k_stream_MAXINDEX, sizeof(__pyx_k_stream_MAXINDEX), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_MAXINDEX */
+  {__pyx_k_stream_MEDPRICE, sizeof(__pyx_k_stream_MEDPRICE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_MEDPRICE */
+  {__pyx_k_stream_MFI, sizeof(__pyx_k_stream_MFI), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_MFI */
+  {__pyx_k_stream_MIDPOINT, sizeof(__pyx_k_stream_MIDPOINT), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_MIDPOINT */
+  {__pyx_k_stream_MIDPRICE, sizeof(__pyx_k_stream_MIDPRICE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_MIDPRICE */
+  {__pyx_k_stream_MIN, sizeof(__pyx_k_stream_MIN), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_MIN */
+  {__pyx_k_stream_MININDEX, sizeof(__pyx_k_stream_MININDEX), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_MININDEX */
+  {__pyx_k_stream_MINMAX, sizeof(__pyx_k_stream_MINMAX), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_MINMAX */
+  {__pyx_k_stream_MINMAXINDEX, sizeof(__pyx_k_stream_MINMAXINDEX), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_MINMAXINDEX */
+  {__pyx_k_stream_MINUS_DI, sizeof(__pyx_k_stream_MINUS_DI), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_MINUS_DI */
+  {__pyx_k_stream_MINUS_DM, sizeof(__pyx_k_stream_MINUS_DM), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_MINUS_DM */
+  {__pyx_k_stream_MOM, sizeof(__pyx_k_stream_MOM), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_MOM */
+  {__pyx_k_stream_MULT, sizeof(__pyx_k_stream_MULT), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_MULT */
+  {__pyx_k_stream_NATR, sizeof(__pyx_k_stream_NATR), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_NATR */
+  {__pyx_k_stream_OBV, sizeof(__pyx_k_stream_OBV), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_OBV */
+  {__pyx_k_stream_PLUS_DI, sizeof(__pyx_k_stream_PLUS_DI), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_PLUS_DI */
+  {__pyx_k_stream_PLUS_DM, sizeof(__pyx_k_stream_PLUS_DM), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_PLUS_DM */
+  {__pyx_k_stream_PPO, sizeof(__pyx_k_stream_PPO), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_PPO */
+  {__pyx_k_stream_ROC, sizeof(__pyx_k_stream_ROC), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_ROC */
+  {__pyx_k_stream_ROCP, sizeof(__pyx_k_stream_ROCP), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_ROCP */
+  {__pyx_k_stream_ROCR, sizeof(__pyx_k_stream_ROCR), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_ROCR */
+  {__pyx_k_stream_ROCR100, sizeof(__pyx_k_stream_ROCR100), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_ROCR100 */
+  {__pyx_k_stream_RSI, sizeof(__pyx_k_stream_RSI), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_RSI */
+  {__pyx_k_stream_SAR, sizeof(__pyx_k_stream_SAR), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_SAR */
+  {__pyx_k_stream_SAREXT, sizeof(__pyx_k_stream_SAREXT), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_SAREXT */
+  {__pyx_k_stream_SIN, sizeof(__pyx_k_stream_SIN), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_SIN */
+  {__pyx_k_stream_SINH, sizeof(__pyx_k_stream_SINH), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_SINH */
+  {__pyx_k_stream_SMA, sizeof(__pyx_k_stream_SMA), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_SMA */
+  {__pyx_k_stream_SQRT, sizeof(__pyx_k_stream_SQRT), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_SQRT */
+  {__pyx_k_stream_STDDEV, sizeof(__pyx_k_stream_STDDEV), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_STDDEV */
+  {__pyx_k_stream_STOCH, sizeof(__pyx_k_stream_STOCH), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_STOCH */
+  {__pyx_k_stream_STOCHF, sizeof(__pyx_k_stream_STOCHF), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_STOCHF */
+  {__pyx_k_stream_STOCHRSI, sizeof(__pyx_k_stream_STOCHRSI), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_STOCHRSI */
+  {__pyx_k_stream_SUB, sizeof(__pyx_k_stream_SUB), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_SUB */
+  {__pyx_k_stream_SUM, sizeof(__pyx_k_stream_SUM), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_SUM */
+  {__pyx_k_stream_T3, sizeof(__pyx_k_stream_T3), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_T3 */
+  {__pyx_k_stream_TAN, sizeof(__pyx_k_stream_TAN), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_TAN */
+  {__pyx_k_stream_TANH, sizeof(__pyx_k_stream_TANH), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_TANH */
+  {__pyx_k_stream_TEMA, sizeof(__pyx_k_stream_TEMA), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_TEMA */
+  {__pyx_k_stream_TRANGE, sizeof(__pyx_k_stream_TRANGE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_TRANGE */
+  {__pyx_k_stream_TRIMA, sizeof(__pyx_k_stream_TRIMA), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_TRIMA */
+  {__pyx_k_stream_TRIX, sizeof(__pyx_k_stream_TRIX), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_TRIX */
+  {__pyx_k_stream_TSF, sizeof(__pyx_k_stream_TSF), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_TSF */
+  {__pyx_k_stream_TYPPRICE, sizeof(__pyx_k_stream_TYPPRICE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_TYPPRICE */
+  {__pyx_k_stream_ULTOSC, sizeof(__pyx_k_stream_ULTOSC), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_ULTOSC */
+  {__pyx_k_stream_VAR, sizeof(__pyx_k_stream_VAR), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_VAR */
+  {__pyx_k_stream_WCLPRICE, sizeof(__pyx_k_stream_WCLPRICE), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_WCLPRICE */
+  {__pyx_k_stream_WILLR, sizeof(__pyx_k_stream_WILLR), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_WILLR */
+  {__pyx_k_stream_WMA, sizeof(__pyx_k_stream_WMA), 0, 1, 1}, /* PyObject cname: __pyx_n_u_stream_WMA */
+  {__pyx_k_stream__s, sizeof(__pyx_k_stream__s), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_stream__s */
+  {__pyx_k_sys, sizeof(__pyx_k_sys), 0, 1, 1}, /* PyObject cname: __pyx_n_u_sys */
+  {__pyx_k_ta_check_success, sizeof(__pyx_k_ta_check_success), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ta_check_success */
+  {__pyx_k_ta_func_unst_ids, sizeof(__pyx_k_ta_func_unst_ids), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ta_func_unst_ids */
+  {__pyx_k_ta_getFuncInfo, sizeof(__pyx_k_ta_getFuncInfo), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ta_getFuncInfo */
+  {__pyx_k_ta_getFuncTable, sizeof(__pyx_k_ta_getFuncTable), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ta_getFuncTable */
+  {__pyx_k_ta_getGroupTable, sizeof(__pyx_k_ta_getGroupTable), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ta_getGroupTable */
+  {__pyx_k_ta_getInputParameterInfo, sizeof(__pyx_k_ta_getInputParameterInfo), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ta_getInputParameterInfo */
+  {__pyx_k_ta_getOptInputParameterInfo, sizeof(__pyx_k_ta_getOptInputParameterInfo), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ta_getOptInputParameterInfo */
+  {__pyx_k_ta_getOutputParameterInfo, sizeof(__pyx_k_ta_getOutputParameterInfo), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ta_getOutputParameterInfo */
+  {__pyx_k_ta_get_compatibility, sizeof(__pyx_k_ta_get_compatibility), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ta_get_compatibility */
+  {__pyx_k_ta_get_unstable_period, sizeof(__pyx_k_ta_get_unstable_period), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ta_get_unstable_period */
+  {__pyx_k_ta_initialize, sizeof(__pyx_k_ta_initialize), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ta_initialize */
+  {__pyx_k_ta_restore_candle_default_setti, sizeof(__pyx_k_ta_restore_candle_default_setti), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ta_restore_candle_default_setti */
+  {__pyx_k_ta_set_candle_settings, sizeof(__pyx_k_ta_set_candle_settings), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ta_set_candle_settings */
+  {__pyx_k_ta_set_compatibility, sizeof(__pyx_k_ta_set_compatibility), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ta_set_compatibility */
+  {__pyx_k_ta_set_unstable_period, sizeof(__pyx_k_ta_set_unstable_period), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ta_set_unstable_period */
+  {__pyx_k_ta_shutdown, sizeof(__pyx_k_ta_shutdown), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ta_shutdown */
+  {__pyx_k_ta_version, sizeof(__pyx_k_ta_version), 0, 1, 1}, /* PyObject cname: __pyx_n_u_ta_version */
+  {__pyx_k_table, sizeof(__pyx_k_table), 0, 1, 1}, /* PyObject cname: __pyx_n_u_table */
+  {__pyx_k_talib__abstract_pxi, sizeof(__pyx_k_talib__abstract_pxi), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_talib__abstract_pxi */
+  {__pyx_k_talib__common_pxi, sizeof(__pyx_k_talib__common_pxi), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_talib__common_pxi */
+  {__pyx_k_talib__func_pxi, sizeof(__pyx_k_talib__func_pxi), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_talib__func_pxi */
+  {__pyx_k_talib__stream_pxi, sizeof(__pyx_k_talib__stream_pxi), 0, 1, 0}, /* PyObject cname: __pyx_kp_u_talib__stream_pxi */
+  {__pyx_k_talib__ta_lib, sizeof(__pyx_k_talib__ta_lib), 0, 1, 1}, /* PyObject cname: __pyx_n_u_talib__ta_lib */
+  {__pyx_k_test, sizeof(__pyx_k_test), 0, 1, 1}, /* PyObject cname: __pyx_n_u_test */
+  {__pyx_k_threading, sizeof(__pyx_k_threading), 0, 1, 1}, /* PyObject cname: __pyx_n_u_threading */
+  {__pyx_k_timeStamp, sizeof(__pyx_k_timeStamp), 0, 1, 1}, /* PyObject cname: __pyx_n_u_timeStamp */
+  {__pyx_k_timeperiod, sizeof(__pyx_k_timeperiod), 0, 1, 1}, /* PyObject cname: __pyx_n_u_timeperiod */
+  {__pyx_k_timeperiod1, sizeof(__pyx_k_timeperiod1), 0, 1, 1}, /* PyObject cname: __pyx_n_u_timeperiod1 */
+  {__pyx_k_timeperiod2, sizeof(__pyx_k_timeperiod2), 0, 1, 1}, /* PyObject cname: __pyx_n_u_timeperiod2 */
+  {__pyx_k_timeperiod3, sizeof(__pyx_k_timeperiod3), 0, 1, 1}, /* PyObject cname: __pyx_n_u_timeperiod3 */
+  {__pyx_k_to_numpy, sizeof(__pyx_k_to_numpy), 0, 1, 1}, /* PyObject cname: __pyx_n_u_to_numpy */
+  {__pyx_k_type, sizeof(__pyx_k_type), 0, 1, 1}, /* PyObject cname: __pyx_n_u_type */
+  {__pyx_k_type_2, sizeof(__pyx_k_type_2), 0, 1, 1}, /* PyObject cname: __pyx_n_u_type_2 */
+  {__pyx_k_unicode, sizeof(__pyx_k_unicode), 0, 1, 1}, /* PyObject cname: __pyx_n_u_unicode */
+  {__pyx_k_update, sizeof(__pyx_k_update), 0, 1, 1}, /* PyObject cname: __pyx_n_u_update */
+  {__pyx_k_update_info, sizeof(__pyx_k_update_info), 0, 1, 1}, /* PyObject cname: __pyx_n_u_update_info */
+  {__pyx_k_upper, sizeof(__pyx_k_upper), 0, 1, 1}, /* PyObject cname: __pyx_n_u_upper */
+  {__pyx_k_value, sizeof(__pyx_k_value), 0, 1, 1}, /* PyObject cname: __pyx_n_u_value */
+  {__pyx_k_value_range, sizeof(__pyx_k_value_range), 0, 1, 1}, /* PyObject cname: __pyx_n_u_value_range */
+  {__pyx_k_values, sizeof(__pyx_k_values), 0, 1, 1}, /* PyObject cname: __pyx_n_u_values */
+  {__pyx_k_version, sizeof(__pyx_k_version), 0, 1, 1}, /* PyObject cname: __pyx_n_u_version */
+  {__pyx_k_vfactor, sizeof(__pyx_k_vfactor), 0, 1, 1}, /* PyObject cname: __pyx_n_u_vfactor */
+  {__pyx_k_volume, sizeof(__pyx_k_volume), 0, 1, 1}, /* PyObject cname: __pyx_n_u_volume */
+  {__pyx_k_volume_data, sizeof(__pyx_k_volume_data), 0, 1, 1}, /* PyObject cname: __pyx_n_u_volume_data */
+  {0, 0, 0, 0, 0}
+};
+/* InitStrings.proto */
+static int __Pyx_InitStrings(__Pyx_StringTabEntry const *t, PyObject **target, const char* const* encoding_names);
+
+/* #### Code section: cached_builtins ### */
+
+static int __Pyx_InitCachedBuiltins(__pyx_mstatetype *__pyx_mstate) {
+  CYTHON_UNUSED_VAR(__pyx_mstate);
+  __pyx_builtin_object = __Pyx_GetBuiltinName(__pyx_mstate->__pyx_n_u_object); if (!__pyx_builtin_object) __PYX_ERR(1, 60, __pyx_L1_error)
+  __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_mstate->__pyx_n_u_range); if (!__pyx_builtin_range) __PYX_ERR(1, 61, __pyx_L1_error)
+  __pyx_builtin_enumerate = __Pyx_GetBuiltinName(__pyx_mstate->__pyx_n_u_enumerate); if (!__pyx_builtin_enumerate) __PYX_ERR(1, 82, __pyx_L1_error)
+  __pyx_builtin_ImportError = __Pyx_GetBuiltinName(__pyx_mstate->__pyx_n_u_ImportError); if (!__pyx_builtin_ImportError) __PYX_ERR(2, 8, __pyx_L1_error)
+  __pyx_builtin_ModuleNotFoundError = __Pyx_GetBuiltinName(__pyx_mstate->__pyx_n_u_ModuleNotFoundError); if (!__pyx_builtin_ModuleNotFoundError) __PYX_ERR(2, 39, __pyx_L1_error)
+  __pyx_builtin_NameError = __Pyx_GetBuiltinName(__pyx_mstate->__pyx_n_u_NameError); if (!__pyx_builtin_NameError) __PYX_ERR(2, 43, __pyx_L1_error)
+  __pyx_builtin_property = __Pyx_GetBuiltinName(__pyx_mstate->__pyx_n_u_property); if (!__pyx_builtin_property) __PYX_ERR(2, 130, __pyx_L1_error)
+  __pyx_builtin_xrange = __Pyx_GetBuiltinName(__pyx_mstate->__pyx_n_u_range); if (!__pyx_builtin_xrange) __PYX_ERR(2, 147, __pyx_L1_error)
+  __pyx_builtin_IndexError = __Pyx_GetBuiltinName(__pyx_mstate->__pyx_n_u_IndexError); if (!__pyx_builtin_IndexError) __PYX_ERR(2, 436, __pyx_L1_error)
+  __pyx_builtin_TypeError = __Pyx_GetBuiltinName(__pyx_mstate->__pyx_n_u_TypeError); if (!__pyx_builtin_TypeError) __PYX_ERR(2, 440, __pyx_L1_error)
+  __pyx_builtin_min = __Pyx_GetBuiltinName(__pyx_mstate->__pyx_n_u_min); if (!__pyx_builtin_min) __PYX_ERR(2, 598, __pyx_L1_error)
+  __pyx_builtin_max = __Pyx_GetBuiltinName(__pyx_mstate->__pyx_n_u_max); if (!__pyx_builtin_max) __PYX_ERR(2, 599, __pyx_L1_error)
+  return 0;
+  __pyx_L1_error:;
+  return -1;
+}
+/* #### Code section: cached_constants ### */
+
+static int __Pyx_InitCachedConstants(__pyx_mstatetype *__pyx_mstate) {
+  __Pyx_RefNannyDeclarations
+  CYTHON_UNUSED_VAR(__pyx_mstate);
+  __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0);
+
+  __pyx_mstate_global->__pyx_tuple[0] = PyTuple_Pack(2, __pyx_mstate_global->__pyx_n_u_real, __pyx_mstate_global->__pyx_n_u_price); if (unlikely(!__pyx_mstate_global->__pyx_tuple[0])) __PYX_ERR(2, 679, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[0]);
+  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[0]);
+
+  __pyx_mstate_global->__pyx_tuple[1] = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_mstate_global->__pyx_tuple[1])) __PYX_ERR(1, 60, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[1]);
+  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[1]);
+  __pyx_mstate_global->__pyx_tuple[2] = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_mstate_global->__pyx_tuple[2])) __PYX_ERR(1, 60, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[2]);
+  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[2]);
+
+  __pyx_mstate_global->__pyx_tuple[3] = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_mstate_global->__pyx_tuple[3])) __PYX_ERR(1, 112, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[3]);
+  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[3]);
+  __pyx_mstate_global->__pyx_tuple[4] = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_mstate_global->__pyx_tuple[4])) __PYX_ERR(1, 112, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[4]);
+  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[4]);
+
+  __pyx_mstate_global->__pyx_tuple[5] = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_mstate_global->__pyx_tuple[5])) __PYX_ERR(1, 119, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[5]);
+  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[5]);
+  __pyx_mstate_global->__pyx_tuple[6] = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_mstate_global->__pyx_tuple[6])) __PYX_ERR(1, 119, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[6]);
+  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[6]);
+
+  __pyx_mstate_global->__pyx_tuple[7] = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_mstate_global->__pyx_tuple[7])) __PYX_ERR(2, 88, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[7]);
+  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[7]);
+  __pyx_mstate_global->__pyx_tuple[8] = PyTuple_Pack(1, __pyx_builtin_object); if (unlikely(!__pyx_mstate_global->__pyx_tuple[8])) __PYX_ERR(2, 88, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[8]);
+  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[8]);
+
+  __pyx_mstate_global->__pyx_tuple[9] = PyTuple_Pack(1, Py_None); if (unlikely(!__pyx_mstate_global->__pyx_tuple[9])) __PYX_ERR(2, 286, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[9]);
+  __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[9]);
+  __Pyx_RefNannyFinishContext();
+  return 0;
+  __pyx_L1_error:;
+  __Pyx_RefNannyFinishContext();
+  return -1;
+}
+/* #### Code section: init_constants ### */
+
+static int __Pyx_InitConstants(__pyx_mstatetype *__pyx_mstate) {
+  CYTHON_UNUSED_VAR(__pyx_mstate);
+  __pyx_mstate->__pyx_umethod_PyDict_Type_keys.type = (PyObject*)&PyDict_Type;
+  __pyx_mstate->__pyx_umethod_PyDict_Type_keys.method_name = &__pyx_mstate->__pyx_n_u_keys;
+  __pyx_mstate->__pyx_umethod_PyDict_Type_pop.type = (PyObject*)&PyDict_Type;
+  __pyx_mstate->__pyx_umethod_PyDict_Type_pop.method_name = &__pyx_mstate->__pyx_n_u_pop;
+  if (__Pyx_InitStrings(__pyx_string_tab, __pyx_mstate->__pyx_string_tab, __pyx_string_tab_encodings) < 0) __PYX_ERR(0, 1, __pyx_L1_error);
+  __pyx_mstate->__pyx_int_0 = PyLong_FromLong(0); if (unlikely(!__pyx_mstate->__pyx_int_0)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __pyx_mstate->__pyx_int_1 = PyLong_FromLong(1); if (unlikely(!__pyx_mstate->__pyx_int_1)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __pyx_mstate->__pyx_int_2 = PyLong_FromLong(2); if (unlikely(!__pyx_mstate->__pyx_int_2)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __pyx_mstate->__pyx_int_3 = PyLong_FromLong(3); if (unlikely(!__pyx_mstate->__pyx_int_3)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __pyx_mstate->__pyx_int_4 = PyLong_FromLong(4); if (unlikely(!__pyx_mstate->__pyx_int_4)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __pyx_mstate->__pyx_int_8 = PyLong_FromLong(8); if (unlikely(!__pyx_mstate->__pyx_int_8)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __pyx_mstate->__pyx_int_9 = PyLong_FromLong(9); if (unlikely(!__pyx_mstate->__pyx_int_9)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __pyx_mstate->__pyx_int_12 = PyLong_FromLong(12); if (unlikely(!__pyx_mstate->__pyx_int_12)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __pyx_mstate->__pyx_int_16 = PyLong_FromLong(16); if (unlikely(!__pyx_mstate->__pyx_int_16)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __pyx_mstate->__pyx_int_32 = PyLong_FromLong(32); if (unlikely(!__pyx_mstate->__pyx_int_32)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __pyx_mstate->__pyx_int_64 = PyLong_FromLong(64); if (unlikely(!__pyx_mstate->__pyx_int_64)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __pyx_mstate->__pyx_int_128 = PyLong_FromLong(128); if (unlikely(!__pyx_mstate->__pyx_int_128)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __pyx_mstate->__pyx_int_256 = PyLong_FromLong(256); if (unlikely(!__pyx_mstate->__pyx_int_256)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __pyx_mstate->__pyx_int_512 = PyLong_FromLong(512); if (unlikely(!__pyx_mstate->__pyx_int_512)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __pyx_mstate->__pyx_int_1024 = PyLong_FromLong(1024); if (unlikely(!__pyx_mstate->__pyx_int_1024)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __pyx_mstate->__pyx_int_2048 = PyLong_FromLong(2048); if (unlikely(!__pyx_mstate->__pyx_int_2048)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __pyx_mstate->__pyx_int_4096 = PyLong_FromLong(4096); if (unlikely(!__pyx_mstate->__pyx_int_4096)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __pyx_mstate->__pyx_int_16777216 = PyLong_FromLong(16777216L); if (unlikely(!__pyx_mstate->__pyx_int_16777216)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __pyx_mstate->__pyx_int_67108864 = PyLong_FromLong(67108864L); if (unlikely(!__pyx_mstate->__pyx_int_67108864)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __pyx_mstate->__pyx_int_134217728 = PyLong_FromLong(134217728L); if (unlikely(!__pyx_mstate->__pyx_int_134217728)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __pyx_mstate->__pyx_int_268435456 = PyLong_FromLong(268435456L); if (unlikely(!__pyx_mstate->__pyx_int_268435456)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __pyx_mstate->__pyx_int_neg_1 = PyLong_FromLong(-1); if (unlikely(!__pyx_mstate->__pyx_int_neg_1)) __PYX_ERR(0, 1, __pyx_L1_error)
+  return 0;
+  __pyx_L1_error:;
+  return -1;
+}
+/* #### Code section: init_codeobjects ### */
+\
+        typedef struct {
+            unsigned int argcount : 4;
+            unsigned int num_posonly_args : 1;
+            unsigned int num_kwonly_args : 1;
+            unsigned int nlocals : 5;
+            unsigned int flags : 10;
+            unsigned int first_line : 13;
+            unsigned int line_table_length : 14;
+        } __Pyx_PyCode_New_function_description;
+/* NewCodeObj.proto */
+static PyObject* __Pyx_PyCode_New(
+        const __Pyx_PyCode_New_function_description descr,
+        PyObject * const *varnames,
+        PyObject *filename,
+        PyObject *funcname,
+        const char *line_table,
+        PyObject *tuple_dedup_map
+);
+
+
+static int __Pyx_CreateCodeObjects(__pyx_mstatetype *__pyx_mstate) {
+  PyObject* tuple_dedup_map = PyDict_New();
+  if (unlikely(!tuple_dedup_map)) return -1;
+  {
+    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 6, 253};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_function_name, __pyx_mstate->__pyx_n_u_ret_code};
+    __pyx_mstate_global->__pyx_codeobj_tab[0] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__common_pxi, __pyx_mstate->__pyx_n_u_ta_check_success, __pyx_k_y_1_q_Q_a_Q_a_Q_a_Q_a_Q_a_Q_a_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[0])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {0, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 50, 19};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_ret_code};
+    __pyx_mstate_global->__pyx_codeobj_tab[1] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__common_pxi, __pyx_mstate->__pyx_n_u_ta_initialize, __pyx_k_Q_q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[1])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {0, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 55, 18};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_ret_code};
+    __pyx_mstate_global->__pyx_codeobj_tab[2] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__common_pxi, __pyx_mstate->__pyx_n_u_ta_shutdown, __pyx_k_a_QoQ, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[2])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 63, 70};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self};
+    __pyx_mstate_global->__pyx_codeobj_tab[3] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__common_pxi, __pyx_mstate->__pyx_n_u_init, __pyx_k_A_A_6_6_6_7_7_81_7_7_5, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[3])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 76, 13};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_type};
+    __pyx_mstate_global->__pyx_codeobj_tab[4] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__common_pxi, __pyx_mstate->__pyx_n_u_getitem, __pyx_k_A_t81A, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[4])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 4, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 90, 34};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_name, __pyx_mstate->__pyx_n_u_period, __pyx_mstate->__pyx_n_u_ret_code, __pyx_mstate->__pyx_n_u_id};
+    __pyx_mstate_global->__pyx_codeobj_tab[5] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__common_pxi, __pyx_mstate->__pyx_n_u_ta_set_unstable_period, __pyx_k_Qa_q_A_Q_a, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[5])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 3, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 96, 27};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_name, __pyx_mstate->__pyx_n_u_period, __pyx_mstate->__pyx_n_u_id};
+    __pyx_mstate_global->__pyx_codeobj_tab[6] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__common_pxi, __pyx_mstate->__pyx_n_u_ta_get_unstable_period, __pyx_k_Qa_Qa_1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[6])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 102, 22};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_value, __pyx_mstate->__pyx_n_u_ret_code};
+    __pyx_mstate_global->__pyx_codeobj_tab[7] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__common_pxi, __pyx_mstate->__pyx_n_u_ta_set_compatibility, __pyx_k_aq_Q_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[7])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {0, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 107, 15};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_value};
+    __pyx_mstate_global->__pyx_codeobj_tab[8] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__common_pxi, __pyx_mstate->__pyx_n_u_ta_get_compatibility, __pyx_k_1_1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[8])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 5, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 124, 28};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_settingtype, __pyx_mstate->__pyx_n_u_rangetype, __pyx_mstate->__pyx_n_u_avgperiod, __pyx_mstate->__pyx_n_u_factor, __pyx_mstate->__pyx_n_u_ret_code};
+    __pyx_mstate_global->__pyx_codeobj_tab[9] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__common_pxi, __pyx_mstate->__pyx_n_u_ta_set_candle_settings, __pyx_k_q_1_Q_a, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[9])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 129, 22};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_settingtype, __pyx_mstate->__pyx_n_u_ret_code};
+    __pyx_mstate_global->__pyx_codeobj_tab[10] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__common_pxi, __pyx_mstate->__pyx_n_u_ta_restore_candle_default_setti, __pyx_k_2_1_Q_9, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[10])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 14, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 142, 359};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outrealupperband, __pyx_mstate->__pyx_n_u_outrealmiddleband, __pyx_mstate->__pyx_n_u_outreallowerband};
+    __pyx_mstate_global->__pyx_codeobj_tab[11] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_ACCBANDS, __pyx_k_aq_Qa_Kq_6_a_8_T_3hjX_U_7_A_w, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[11])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 9, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 181, 138};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[12] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_ACOS, __pyx_k_aq_T_q_8_T_U_7_A_we_A_q_4y_4vQi, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[12])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 210, 297};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_volume, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[13] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_AD, __pyx_k_aq_Qa_Kq_6_gQ_8_T_3hjX_eeoouuv, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[13])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 242, 193};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real0, __pyx_mstate->__pyx_n_u_real1, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[14] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_ADD, __pyx_k_Kq_Kq_7_8_U_E_U_7_A_we_1_q_i_vQ, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[14])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {6, 0, 0, 14, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 273, 330};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_volume, __pyx_mstate->__pyx_n_u_fastperiod, __pyx_mstate->__pyx_n_u_slowperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[15] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_ADOSC, __pyx_k_z_R_R_S_aq_Qa_Kq_6_gQ_8_T_3hjX, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[15])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 308, 255};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[16] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_ADX, __pyx_k_Z_aq_Qa_Kq_6_a_8_T_3hjX_U_7_A_w, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[16])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 341, 255};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[17] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_ADXR, __pyx_k_aq_Qa_Kq_6_a_8_T_3hjX_U_7_A_we, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[17])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 374, 187};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_fastperiod, __pyx_mstate->__pyx_n_u_slowperiod, __pyx_mstate->__pyx_n_u_matype, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[18] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_APO, __pyx_k_TTU_aq_T_q_8_T_U_7_A_we_2_q_q_i, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[18])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 407, 258};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outaroondown, __pyx_mstate->__pyx_n_u_outaroonup};
+    __pyx_mstate_global->__pyx_codeobj_tab[19] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_AROON, __pyx_k_A_aq_Qa_6_8_T_3a_U_7_A_we_Rq_AX, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[19])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 11, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 442, 209};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[20] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_AROONOSC, __pyx_k_CD_aq_Qa_6_8_T_3a_U_7_A_we_0_q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[20])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 9, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 474, 138};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[21] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_ASIN, __pyx_k_aq_T_q_8_T_U_7_A_we_A_q_4y_4vQi, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[21])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 9, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 503, 138};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[22] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_ATAN, __pyx_k_aq_T_q_8_T_U_7_A_we_A_q_4y_4vQi, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[22])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 532, 255};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[23] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_ATR, __pyx_k_Z_aq_Qa_Kq_6_a_8_T_3hjX_U_7_A_w, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[23])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 565, 298};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[24] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_AVGPRICE, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[24])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 597, 163};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[25] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_AVGDEV, __pyx_k_aq_T_q_8_T_U_7_A_we_b_q_2T_T_q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[25])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {5, 0, 0, 15, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 628, 304};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_nbdevup, __pyx_mstate->__pyx_n_u_nbdevdn, __pyx_mstate->__pyx_n_u_matype, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outrealupperband, __pyx_mstate->__pyx_n_u_outrealmiddleband, __pyx_mstate->__pyx_n_u_outreallowerband};
+    __pyx_mstate_global->__pyx_codeobj_tab[26] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_BBANDS, __pyx_k_VVmmn4_aq_T_q_8_T_U_7_A_we_b_Zz, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[26])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 11, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 668, 209};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real0, __pyx_mstate->__pyx_n_u_real1, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[27] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_BETA, __pyx_k_BC_Kq_Kq_7_8_U_E_U_7_A_we_Ba_q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[27])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 701, 298};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[28] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_BOP, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_2, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[28])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 733, 255};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[29] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CCI, __pyx_k_Z_aq_Qa_Kq_6_a_8_T_3hjX_U_7_A_w, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[29])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 766, 302};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[30] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDL2CROWS, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_3, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[30])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 798, 308};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[31] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDL3BLACKCROWS, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_4, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[31])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 830, 306};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[32] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDL3INSIDE, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_5, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[32])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 862, 308};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[33] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDL3LINESTRIKE, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_4, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[33])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 894, 306};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[34] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDL3OUTSIDE, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_6, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[34])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 926, 312};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[35] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDL3STARSINSOUTH, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_7, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[35])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 958, 312};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[36] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDL3WHITESOLDIERS, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_8, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[36])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {5, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 990, 328};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_penetration, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[37] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLABANDONEDBABY, __pyx_k_C_D_aq_aq_Qa_Kq_6_uA_8_T_4xzY_d, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[37])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1024, 308};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[38] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLADVANCEBLOCK, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_9, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[38])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1056, 306};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[39] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLBELTHOLD, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_6, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[39])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1088, 307};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[40] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLBREAKAWAY, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_10, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[40])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1120, 312};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[41] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLCLOSINGMARUBOZU, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_11, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[41])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1152, 316};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[42] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLCONCEALBABYSWALL, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_12, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[42])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1184, 312};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[43] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLCOUNTERATTACK, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_7, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[43])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {5, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1216, 328};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_penetration, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[44] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLDARKCLOUDCOVER, __pyx_k_D_E_aq_aq_Qa_Kq_6_uA_8_T_4xzY_d, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[44])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1250, 297};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[45] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLDOJI, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_13, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[45])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1282, 306};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[46] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLDOJISTAR, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_6, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[46])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1314, 312};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[47] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLDRAGONFLYDOJI, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_7, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[47])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1346, 307};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[48] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLENGULFING, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_10, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[48])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {5, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1378, 328};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_penetration, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[49] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLEVENINGDOJISTAR, __pyx_k_E_F_aq_aq_Qa_Kq_6_uA_8_T_4xzY_d, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[49])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {5, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1412, 324};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_penetration, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[50] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLEVENINGSTAR, __pyx_k_A_B_aq_aq_Qa_Kq_6_uA_8_T_4xzY_d, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[50])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1446, 316};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[51] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLGAPSIDESIDEWHITE, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_12, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[51])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1478, 312};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[52] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLGRAVESTONEDOJI, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_8, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[52])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1510, 302};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[53] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLHAMMER, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_3, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[53])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1542, 308};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[54] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLHANGINGMAN, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_14, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[54])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1574, 302};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[55] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLHARAMI, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_3, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[55])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1606, 308};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[56] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLHARAMICROSS, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_4, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[56])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1638, 306};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[57] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLHIGHWAVE, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_6, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[57])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1670, 306};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[58] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLHIKKAKE, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_5, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[58])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1702, 308};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[59] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLHIKKAKEMOD, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_14, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[59])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1734, 308};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[60] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLHOMINGPIGEON, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_9, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[60])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1766, 312};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[61] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLIDENTICAL3CROWS, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_11, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[61])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1798, 302};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[62] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLINNECK, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_3, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[62])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1830, 312};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[63] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLINVERTEDHAMMER, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_8, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[63])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1862, 306};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[64] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLKICKING, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_5, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[64])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1894, 312};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[65] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLKICKINGBYLENGTH, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_11, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[65])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1926, 308};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[66] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLLADDERBOTTOM, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_9, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[66])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1958, 312};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[67] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLLONGLEGGEDDOJI, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_8, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[67])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1990, 306};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[68] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLLONGLINE, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_6, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[68])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2022, 306};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[69] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLMARUBOZU, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_6, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[69])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2054, 308};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[70] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLMATCHINGLOW, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_4, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[70])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {5, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2086, 318};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_penetration, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[71] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLMATHOLD, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_15, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[71])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {5, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2120, 328};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_penetration, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[72] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLMORNINGDOJISTAR, __pyx_k_E_F_aq_aq_Qa_Kq_6_uA_8_T_4xzY_d, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[72])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {5, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2154, 324};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_penetration, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[73] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLMORNINGSTAR, __pyx_k_A_B_aq_aq_Qa_Kq_6_uA_8_T_4xzY_d, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[73])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2188, 302};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[74] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLONNECK, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_3, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[74])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2220, 306};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[75] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLPIERCING, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_6, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[75])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2252, 308};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[76] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLRICKSHAWMAN, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_4, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[76])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2284, 316};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[77] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLRISEFALL3METHODS, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_12, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[77])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2316, 312};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[78] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLSEPARATINGLINES, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_11, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[78])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2348, 308};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[79] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLSHOOTINGSTAR, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_9, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[79])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2380, 307};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[80] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLSHORTLINE, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_10, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[80])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2412, 308};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[81] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLSPINNINGTOP, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_4, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[81])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2444, 312};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[82] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLSTALLEDPATTERN, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_8, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[82])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2476, 312};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[83] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLSTICKSANDWICH, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_7, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[83])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2508, 302};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[84] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLTAKURI, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_3, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[84])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2540, 307};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[85] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLTASUKIGAP, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_10, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[85])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2572, 307};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[86] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLTHRUSTING, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_10, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[86])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2604, 306};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[87] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLTRISTAR, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_5, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[87])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2636, 308};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[88] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLUNIQUE3RIVER, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_9, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[88])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2668, 312};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[89] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLUPSIDEGAP2CROWS, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_11, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[89])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2700, 316};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[90] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CDLXSIDEGAP3METHODS, __pyx_k_aq_aq_Qa_Kq_6_uA_8_T_4xzY_ddnns_12, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[90])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 9, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2732, 138};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[91] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CEIL, __pyx_k_aq_T_q_8_T_U_7_A_we_A_q_4y_4vQi, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[91])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2761, 163};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[92] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CMO, __pyx_k_aq_T_q_8_T_U_7_A_we_2Q_q_i_fAYm, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[92])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 11, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2792, 209};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real0, __pyx_mstate->__pyx_n_u_real1, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[93] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_CORREL, __pyx_k_DE_Kq_Kq_7_8_U_E_U_7_A_we_b_q_2, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[93])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 9, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2825, 138};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[94] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_COS, __pyx_k_aq_T_q_8_T_U_7_A_we_1_q_i_fAYa, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[94])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 9, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2854, 138};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[95] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_COSH, __pyx_k_aq_T_q_8_T_U_7_A_we_A_q_4y_4vQi, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[95])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2883, 163};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[96] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_DEMA, __pyx_k_aq_T_q_8_T_U_7_A_we_Ba_q_4y_4vQ, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[96])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2914, 193};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real0, __pyx_mstate->__pyx_n_u_real1, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[97] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_DIV, __pyx_k_Kq_Kq_7_8_U_E_U_7_A_we_1_q_i_vQ, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[97])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2945, 254};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[98] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_DX, __pyx_k_YZ_aq_Qa_Kq_6_a_8_T_3hjX_U_7_A, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[98])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2978, 163};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[99] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_EMA, __pyx_k_aq_T_q_8_T_U_7_A_we_2Q_q_i_fAYm, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[99])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 9, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3009, 138};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[100] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_EXP, __pyx_k_aq_T_q_8_T_U_7_A_we_1_q_i_fAYa, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[100])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 9, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3038, 138};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[101] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_FLOOR, __pyx_k_aq_T_q_8_T_U_7_A_we_Q_q_D_D_ay, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[101])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 9, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3067, 151};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[102] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_HT_DCPERIOD, __pyx_k_aq_T_q_8_T_U_7_A_we_31_q_i_fAYa, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[102])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 9, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3096, 151};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[103] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_HT_DCPHASE, __pyx_k_aq_T_q_8_T_U_7_A_we_2_q_r_Yk_V1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[103])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3125, 200};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinphase, __pyx_mstate->__pyx_n_u_outquadrature};
+    __pyx_mstate_global->__pyx_codeobj_tab[104] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_HT_PHASOR, __pyx_k_aq_T_q_8_T_U_7_A_we_1_81_Qha_b, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[104])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3157, 195};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outsine, __pyx_mstate->__pyx_n_u_outleadsine};
+    __pyx_mstate_global->__pyx_codeobj_tab[105] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_HT_SINE, __pyx_k_aq_T_q_8_T_U_7_A_we_q_q_1HA_Bd, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[105])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 9, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3189, 153};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[106] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_HT_TRENDLINE, __pyx_k_aq_T_q_8_T_U_7_A_we_4A_q_4y_4vQ, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[106])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 9, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3218, 152};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[107] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_HT_TRENDMODE, __pyx_k_aq_T_q_8_T_U_7_A_we_4A_q_4y_4vQ_2, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[107])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 11, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3247, 209};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[108] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_IMI, __pyx_k_A_aq_Kq_6_8_T_5_U_7_A_we_2Q_q_i, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[108])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3279, 163};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[109] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_KAMA, __pyx_k_aq_T_q_8_T_U_7_A_we_Ba_q_4y_4vQ, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[109])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3310, 168};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[110] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_LINEARREG, __pyx_k_aq_T_q_8_T_U_7_A_we_1_1_q_b_I_F, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[110])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3341, 170};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[111] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_LINEARREG_ANGLE, __pyx_k_01_aq_T_q_8_T_U_7_A_we_7r_q_Bd, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[111])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3372, 174};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[112] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_LINEARREG_INTERCEPT, __pyx_k_45_aq_T_q_8_T_U_7_A_we_2Q_q_i_f, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[112])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3403, 170};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[113] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_LINEARREG_SLOPE, __pyx_k_01_aq_T_q_8_T_U_7_A_we_7r_q_Bd, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[113])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 9, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3434, 137};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[114] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_LN, __pyx_k_aq_T_q_8_T_U_7_A_we_q_r_Yk_V1IQ, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[114])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 9, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3463, 138};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[115] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_LOG10, __pyx_k_aq_T_q_8_T_U_7_A_we_Q_q_D_D_ay, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[115])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 11, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3492, 173};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_matype, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[116] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_MA, __pyx_k_1_aq_T_q_8_T_U_7_A_we_M_q_r_Yk, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[116])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 14, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3524, 286};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_fastperiod, __pyx_mstate->__pyx_n_u_slowperiod, __pyx_mstate->__pyx_n_u_signalperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outmacd, __pyx_mstate->__pyx_n_u_outmacdsignal, __pyx_mstate->__pyx_n_u_outmacdhist};
+    __pyx_mstate_global->__pyx_codeobj_tab[117] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_MACD, __pyx_k_UUV2_aq_T_q_8_T_U_7_A_we_Bm_q_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[117])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {7, 0, 0, 17, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3563, 341};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_fastperiod, __pyx_mstate->__pyx_n_u_fastmatype, __pyx_mstate->__pyx_n_u_slowperiod, __pyx_mstate->__pyx_n_u_slowmatype, __pyx_mstate->__pyx_n_u_signalperiod, __pyx_mstate->__pyx_n_u_signalmatype, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outmacd, __pyx_mstate->__pyx_n_u_outmacdsignal, __pyx_mstate->__pyx_n_u_outmacdhist};
+    __pyx_mstate_global->__pyx_codeobj_tab[118] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_MACDEXT, __pyx_k_SSkk_Y_Y_Z_8_aq_T_q_8_T_U_7_A_w, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[118])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3605, 266};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_signalperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outmacd, __pyx_mstate->__pyx_n_u_outmacdsignal, __pyx_mstate->__pyx_n_u_outmacdhist};
+    __pyx_mstate_global->__pyx_codeobj_tab[119] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_MACDFIX, __pyx_k_aq_T_q_8_T_U_7_A_we_r_q_Qha_1HA, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[119])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3642, 223};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_fastlimit, __pyx_mstate->__pyx_n_u_slowlimit, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outmama, __pyx_mstate->__pyx_n_u_outfama};
+    __pyx_mstate_global->__pyx_codeobj_tab[120] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_MAMA, __pyx_k_a_aq_T_q_8_T_U_7_A_we_Bl_q_q_4y, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[120])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {5, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3677, 237};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_periods, __pyx_mstate->__pyx_n_u_minperiod, __pyx_mstate->__pyx_n_u_maxperiod, __pyx_mstate->__pyx_n_u_matype, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[121] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_MAVP, __pyx_k_CZZqqr_aq_k_6_8_T_7_U_7_A_we_Bl, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[121])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3712, 163};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[122] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_MAX, __pyx_k_aq_T_q_8_T_U_7_A_we_2Q_q_i_fAYm, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[122])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3743, 190};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger, __pyx_mstate->__pyx_n_u_outinteger_data, __pyx_mstate->__pyx_n_u_i};
+    __pyx_mstate_global->__pyx_codeobj_tab[123] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_MAXINDEX, __pyx_k_aq_T_q_8_T_U_7_A_we_0_q_Rt9Kt6, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[123])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3777, 193};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[124] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_MEDPRICE, __pyx_k_aq_Qa_6_8_T_3a_U_7_A_we_0_q_Rt9, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[124])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {5, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3807, 310};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_volume, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[125] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_MFI, __pyx_k_wx_aq_Qa_Kq_6_gQ_8_T_3hjX_eeoou, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[125])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3841, 167};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[126] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_MIDPOINT, __pyx_k_aq_T_q_8_T_U_7_A_we_0_q_Rt9Kt6_2, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[126])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 11, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3872, 209};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[127] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_MIDPRICE, __pyx_k_CD_aq_Qa_6_8_T_3a_U_7_A_we_0_q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[127])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3904, 163};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[128] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_MIN, __pyx_k_aq_T_q_8_T_U_7_A_we_2Q_q_i_fAYm, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[128])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3935, 190};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger, __pyx_mstate->__pyx_n_u_outinteger_data, __pyx_mstate->__pyx_n_u_i};
+    __pyx_mstate_global->__pyx_codeobj_tab[129] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_MININDEX, __pyx_k_aq_T_q_8_T_U_7_A_we_0_q_Rt9Kt6, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[129])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 11, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3969, 212};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outmin, __pyx_mstate->__pyx_n_u_outmax};
+    __pyx_mstate_global->__pyx_codeobj_tab[130] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_MINMAX, __pyx_k_aq_T_q_8_T_U_7_A_we_b_axq_axq_2, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[130])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 14, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4003, 271};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outminidx, __pyx_mstate->__pyx_n_u_outmaxidx, __pyx_mstate->__pyx_n_u_outminidx_data, __pyx_mstate->__pyx_n_u_i, __pyx_mstate->__pyx_n_u_outmaxidx_data};
+    __pyx_mstate_global->__pyx_codeobj_tab[131] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_MINMAXINDEX, __pyx_k_aq_T_q_8_T_U_7_A_we_32Q_axq_axq, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[131])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4043, 259};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[132] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_MINUS_DI, __pyx_k_aq_Qa_Kq_6_a_8_T_3hjX_U_7_A_w_2, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[132])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 11, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4076, 209};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[133] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_MINUS_DM, __pyx_k_CD_aq_Qa_6_8_T_3a_U_7_A_we_0_q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[133])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4108, 163};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[134] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_MOM, __pyx_k_aq_T_q_8_T_U_7_A_we_2Q_q_i_fAYm, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[134])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4139, 193};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real0, __pyx_mstate->__pyx_n_u_real1, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[135] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_MULT, __pyx_k_Kq_Kq_7_8_U_E_U_7_A_we_A_q_4y_5, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[135])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4170, 255};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[136] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_NATR, __pyx_k_aq_Qa_Kq_6_a_8_T_3hjX_U_7_A_we, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[136])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4203, 193};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_volume, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[137] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_OBV, __pyx_k_aq_6_8_T_6_U_7_A_we_1_q_i_fAYkQ, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[137])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4234, 255};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[138] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_PLUS_DI, __pyx_k_aq_Qa_Kq_6_a_8_T_3hjX_U_7_A_w_3, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[138])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 11, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4267, 209};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[139] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_PLUS_DM, __pyx_k_BC_aq_Qa_6_8_T_3a_U_7_A_we_r_q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[139])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4299, 187};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_fastperiod, __pyx_mstate->__pyx_n_u_slowperiod, __pyx_mstate->__pyx_n_u_matype, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[140] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_PPO, __pyx_k_TTU_aq_T_q_8_T_U_7_A_we_2_q_q_i, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[140])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4332, 163};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[141] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_ROC, __pyx_k_aq_T_q_8_T_U_7_A_we_2Q_q_i_fAYm, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[141])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4363, 163};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[142] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_ROCP, __pyx_k_aq_T_q_8_T_U_7_A_we_Ba_q_4y_4vQ, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[142])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4394, 163};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[143] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_ROCR, __pyx_k_aq_T_q_8_T_U_7_A_we_Ba_q_4y_4vQ, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[143])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4425, 163};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[144] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_ROCR100, __pyx_k_aq_T_q_8_T_U_7_A_we_r_q_Bd_d_WX, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[144])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4456, 163};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[145] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_RSI, __pyx_k_aq_T_q_8_T_U_7_A_we_2Q_q_i_fAYm, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[145])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4487, 217};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_acceleration, __pyx_mstate->__pyx_n_u_maximum, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[146] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_SAR, __pyx_k_YYZ_aq_Qa_6_8_T_3a_U_7_A_we_2_A, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[146])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {10, 0, 0, 18, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4520, 344};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_startvalue, __pyx_mstate->__pyx_n_u_offsetonreverse, __pyx_mstate->__pyx_n_u_accelerationinitlong, __pyx_mstate->__pyx_n_u_accelerationlong, __pyx_mstate->__pyx_n_u_accelerationmaxlong, __pyx_mstate->__pyx_n_u_accelerationinitshort, __pyx_mstate->__pyx_n_u_accelerationshort, __pyx_mstate->__pyx_n_u_accelerationmaxshort, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[147] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_SAREXT, __pyx_k_A_z_____b_b_G_G_h_h_i_4_aq_Qa_6, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[147])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 9, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4559, 138};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[148] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_SIN, __pyx_k_aq_T_q_8_T_U_7_A_we_1_q_i_fAYa, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[148])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 9, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4588, 138};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[149] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_SINH, __pyx_k_aq_T_q_8_T_U_7_A_we_A_q_4y_4vQi, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[149])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4617, 163};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[150] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_SMA, __pyx_k_aq_T_q_8_T_U_7_A_we_2Q_q_i_fAYm, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[150])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 9, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4648, 138};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[151] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_SQRT, __pyx_k_aq_T_q_8_T_U_7_A_we_A_q_4y_4vQi, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[151])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 11, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4677, 174};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_nbdev, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[152] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_STDDEV, __pyx_k_q_aq_T_q_8_T_U_7_A_we_b_Q_q_2T, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[152])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {8, 0, 0, 17, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4709, 370};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_fastk_period, __pyx_mstate->__pyx_n_u_slowk_period, __pyx_mstate->__pyx_n_u_slowk_matype, __pyx_mstate->__pyx_n_u_slowd_period, __pyx_mstate->__pyx_n_u_slowd_matype, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outslowk, __pyx_mstate->__pyx_n_u_outslowd};
+    __pyx_mstate_global->__pyx_codeobj_tab[153] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_STOCH, __pyx_k_v_w_Q_Q_f_f_A_2_aq_Qa_Kq_6_a_8, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[153])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {6, 0, 0, 15, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4749, 336};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_fastk_period, __pyx_mstate->__pyx_n_u_fastd_period, __pyx_mstate->__pyx_n_u_fastd_matype, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outfastk, __pyx_mstate->__pyx_n_u_outfastd};
+    __pyx_mstate_global->__pyx_codeobj_tab[154] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_STOCHF, __pyx_k_w_x_R_R_S_aq_Qa_Kq_6_a_8_T_3hjX, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[154])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {5, 0, 0, 14, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4787, 261};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_fastk_period, __pyx_mstate->__pyx_n_u_fastd_period, __pyx_mstate->__pyx_n_u_fastd_matype, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outfastk, __pyx_mstate->__pyx_n_u_outfastd};
+    __pyx_mstate_global->__pyx_codeobj_tab[155] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_STOCHRSI, __pyx_k_AA_uuv0_aq_T_q_8_T_U_7_A_we_0_o, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[155])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4824, 193};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real0, __pyx_mstate->__pyx_n_u_real1, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[156] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_SUB, __pyx_k_Kq_Kq_7_8_U_E_U_7_A_we_1_q_i_vQ, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[156])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4855, 163};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[157] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_SUM, __pyx_k_aq_T_q_8_T_U_7_A_we_2Q_q_i_fAYm, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[157])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 11, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4886, 173};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_vfactor, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[158] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_T3, __pyx_k_1_aq_T_q_8_T_U_7_A_we_M_q_r_Yk_2, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[158])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 9, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4918, 138};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[159] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_TAN, __pyx_k_aq_T_q_8_T_U_7_A_we_1_q_i_fAYa, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[159])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 9, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4947, 138};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[160] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_TANH, __pyx_k_aq_T_q_8_T_U_7_A_we_A_q_4y_4vQi, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[160])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4976, 163};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[161] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_TEMA, __pyx_k_aq_T_q_8_T_U_7_A_we_Ba_q_4y_4vQ, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[161])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 11, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 5007, 243};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[162] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_TRANGE, __pyx_k_aq_Qa_Kq_6_a_8_T_3hjX_U_7_A_we_2, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[162])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 5038, 163};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[163] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_TRIMA, __pyx_k_aq_T_q_8_T_U_7_A_we_Rq_q_D_D_ay, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[163])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 5069, 163};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[164] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_TRIX, __pyx_k_aq_T_q_8_T_U_7_A_we_Ba_q_4y_4vQ, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[164])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 5100, 163};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[165] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_TSF, __pyx_k_aq_T_q_8_T_U_7_A_we_2Q_q_i_fAYm, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[165])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 11, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 5131, 247};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[166] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_TYPPRICE, __pyx_k_aq_Qa_Kq_6_a_8_T_3hjX_U_7_A_we_3, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[166])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {6, 0, 0, 14, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 5162, 287};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_timeperiod1, __pyx_mstate->__pyx_n_u_timeperiod2, __pyx_mstate->__pyx_n_u_timeperiod3, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[167] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_ULTOSC, __pyx_k_v_w_P_P_Q_aq_Qa_Kq_6_a_8_T_3hjX, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[167])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 11, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 5197, 174};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_nbdev, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[168] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_VAR, __pyx_k_A_aq_T_q_8_T_U_7_A_we_2_q_i_fAY, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[168])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 11, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 5229, 247};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[169] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_WCLPRICE, __pyx_k_aq_Qa_Kq_6_a_8_T_3hjX_U_7_A_we_3, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[169])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 5260, 255};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[170] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_WILLR, __pyx_k_aq_Qa_Kq_6_a_8_T_3hjX_U_7_A_we_4, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[170])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 5293, 163};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_begidx, __pyx_mstate->__pyx_n_u_endidx, __pyx_mstate->__pyx_n_u_lookback, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[171] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__func_pxi, __pyx_mstate->__pyx_n_u_WMA, __pyx_k_aq_T_q_8_T_U_7_A_we_2Q_q_i_fAYm, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[171])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 74, 13};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_s};
+    __pyx_mstate_global->__pyx_codeobj_tab[172] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_str2bytes, __pyx_k_A_uAS, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[172])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 77, 13};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_b};
+    __pyx_mstate_global->__pyx_codeobj_tab[173] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_bytes2str, __pyx_k_A_q_q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[173])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 82, 7};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_s};
+    __pyx_mstate_global->__pyx_codeobj_tab[174] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_str2bytes, __pyx_k_A_q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[174])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 85, 7};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_b};
+    __pyx_mstate_global->__pyx_codeobj_tab[175] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_bytes2str, __pyx_k_A_q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[175])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 5, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS|CO_VARARGS|CO_VARKEYWORDS), 117, 69};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_function_name, __pyx_mstate->__pyx_n_u_func_object, __pyx_mstate->__pyx_n_u_args, __pyx_mstate->__pyx_n_u_kwargs};
+    __pyx_mstate_global->__pyx_codeobj_tab[176] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_init, __pyx_k_A_Jm6_M_Q_Jiq_A_O9F_b_O1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[176])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 7, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 130, 363};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_local, __pyx_mstate->__pyx_n_u_i, __pyx_mstate->__pyx_n_u_info, __pyx_mstate->__pyx_n_u_input_name, __pyx_mstate->__pyx_n_u_param_name, __pyx_mstate->__pyx_n_u_output_name};
+    __pyx_mstate_global->__pyx_codeobj_tab[177] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_local_2, __pyx_k_A_A_4wawa_1_Kq_Q_V1E_d_1_0_Ya_T, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[177])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 172, 17};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self};
+    __pyx_mstate_global->__pyx_codeobj_tab[178] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_info, __pyx_k_A_t85_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[178])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 179, 17};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self};
+    __pyx_mstate_global->__pyx_codeobj_tab[179] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_function_flags, __pyx_k_A_t85, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[179])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 186, 21};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self};
+    __pyx_mstate_global->__pyx_codeobj_tab[180] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_output_flags, __pyx_k_A_t85_Q_2, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[180])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 4, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 193, 51};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_local, __pyx_mstate->__pyx_n_u_ret, __pyx_mstate->__pyx_n_u_input_name};
+    __pyx_mstate_global->__pyx_codeobj_tab[181] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_get_input_names, __pyx_k_A_A_k_N_q_q_e_q_1A_q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[181])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 5, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 204, 64};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_input_names, __pyx_mstate->__pyx_n_u_local, __pyx_mstate->__pyx_n_u_input_name, __pyx_mstate->__pyx_n_u_price_series};
+    __pyx_mstate_global->__pyx_codeobj_tab[182] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_set_input_names, __pyx_k_A_A_L_6_Qk_A_a_QnA_a, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[182])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 216, 56};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_local};
+    __pyx_mstate_global->__pyx_codeobj_tab[183] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_get_input_arrays, __pyx_k_A_A_gQ_5_q_5_V1_5_U, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[183])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 6, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 227, 167};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_input_arrays, __pyx_mstate->__pyx_n_u_local, __pyx_mstate->__pyx_n_u_missing_keys, __pyx_mstate->__pyx_n_u_key, __pyx_mstate->__pyx_n_u_missing};
+    __pyx_mstate_global->__pyx_codeobj_tab[184] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_set_input_arrays, __pyx_k_A2_A_QnA_1_t_6a_gQ_d_Q_d_1_q_s_A, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[184])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 4, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 276, 48};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_local, __pyx_mstate->__pyx_n_u_ret, __pyx_mstate->__pyx_n_u_opt_input};
+    __pyx_mstate_global->__pyx_codeobj_tab[185] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_get_parameters, __pyx_k_A_A_k_M_a_q_T_7q_q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[185])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 6, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS|CO_VARKEYWORDS), 286, 96};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_parameters, __pyx_mstate->__pyx_n_u_kwargs, __pyx_mstate->__pyx_n_u_local, __pyx_mstate->__pyx_n_u_param, __pyx_mstate->__pyx_n_u_value};
+    __pyx_mstate_global->__pyx_codeobj_tab[186] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_set_parameters, __pyx_k_Q_A_1_G9JfA_t_1G1_q_1_a_U_4q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[186])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS|CO_VARARGS|CO_VARKEYWORDS), 301, 285};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_args, __pyx_mstate->__pyx_n_u_kwargs, __pyx_mstate->__pyx_n_u_local, __pyx_mstate->__pyx_n_u_update_info, __pyx_mstate->__pyx_n_u_key, __pyx_mstate->__pyx_n_u_value, __pyx_mstate->__pyx_n_u_skip_first, __pyx_mstate->__pyx_n_u_i, __pyx_mstate->__pyx_n_u_param_name};
+    __pyx_mstate_global->__pyx_codeobj_tab[187] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_set_function_args, __pyx_k_A_A_a_G1_t3e1_aq_4_q_Q_AT_V1A_S, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[187])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 8, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 336, 143};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_local, __pyx_mstate->__pyx_n_u_holder, __pyx_mstate->__pyx_n_u_i, __pyx_mstate->__pyx_n_u_opt_input, __pyx_mstate->__pyx_n_u_value, __pyx_mstate->__pyx_n_u_type, __pyx_mstate->__pyx_n_u_lookback};
+    __pyx_mstate_global->__pyx_codeobj_tab[188] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_lookback, __pyx_k_A_A_at1_C_IQe1_D_aq_E_AZq_vV_2_V, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[188])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 357, 44};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_ret};
+    __pyx_mstate_global->__pyx_codeobj_tab[189] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_output_names, __pyx_k_A_d_q_4z_q_aq_q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[189])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 4, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 367, 241};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_local, __pyx_mstate->__pyx_n_u_ret, __pyx_mstate->__pyx_n_u_index};
+    __pyx_mstate_global->__pyx_codeobj_tab[190] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_outputs, __pyx_k_A_A_4uA_e87_4z_q_aq_gU_5_q_E_a_s, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[190])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 399, 36};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_input_arrays};
+    __pyx_mstate_global->__pyx_codeobj_tab[191] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_run, __pyx_k_N_1_A_t1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[191])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 16, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS|CO_VARARGS|CO_VARKEYWORDS), 411, 497};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_args, __pyx_mstate->__pyx_n_u_kwargs, __pyx_mstate->__pyx_n_u_local, __pyx_mstate->__pyx_n_u_opt_input_values, __pyx_mstate->__pyx_n_u_price_series_name_values, __pyx_mstate->__pyx_n_u_input_arrays, __pyx_mstate->__pyx_n_u_input_price_series_names, __pyx_mstate->__pyx_n_u_i, __pyx_mstate->__pyx_n_u_arg, __pyx_mstate->__pyx_n_u_msg, __pyx_mstate->__pyx_n_u_no_existing_input_arrays, __pyx_mstate->__pyx_n_u_param_name, __pyx_mstate->__pyx_n_u_value, __pyx_mstate->__pyx_n_u_input_name, __pyx_mstate->__pyx_n_u_n};
+    __pyx_mstate_global->__pyx_codeobj_tab[192] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_call, __pyx_k_A_A_2_k_Qa_e_e1_2S_AQ_U_t1A_q_4, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[192])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 6, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 477, 79};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_local, __pyx_mstate->__pyx_n_u_input_price_series_names, __pyx_mstate->__pyx_n_u_input_name, __pyx_mstate->__pyx_n_u_price_series, __pyx_mstate->__pyx_n_u_name};
+    __pyx_mstate_global->__pyx_codeobj_tab[193] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_input_price_series_names_2, __pyx_k_A_A_1_N_q_5_A_z_HA_G1A_q_q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[193])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 489, 261};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_local, __pyx_mstate->__pyx_n_u_input_price_series_names, __pyx_mstate->__pyx_n_u_args, __pyx_mstate->__pyx_n_u_price_series, __pyx_mstate->__pyx_n_u_series, __pyx_mstate->__pyx_n_u_opt_input, __pyx_mstate->__pyx_n_u_value, __pyx_mstate->__pyx_n_u_results, __pyx_mstate->__pyx_n_u_keys, __pyx_mstate->__pyx_n_u_i, __pyx_mstate->__pyx_n_u_output};
+    __pyx_mstate_global->__pyx_codeobj_tab[194] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_call_function, __pyx_k_A_A_4_B_q_A_U_q_we1_axq_wgQa_Q_a, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[194])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 4, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 520, 104};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_input_name, __pyx_mstate->__pyx_n_u_value, __pyx_mstate->__pyx_n_u_type};
+    __pyx_mstate_global->__pyx_codeobj_tab[195] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_check_opt_input_value, __pyx_k_A_HKq_1A_6_5Q_A_7_4A_A_QgQ_7_1_A, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[195])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 4, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 535, 55};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_input_name, __pyx_mstate->__pyx_n_u_local, __pyx_mstate->__pyx_n_u_value};
+    __pyx_mstate_global->__pyx_codeobj_tab[196] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_get_opt_input_value, __pyx_k_A_A_AQ_6_A_E_A_q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[196])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 545, 13};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self};
+    __pyx_mstate_global->__pyx_codeobj_tab[197] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_repr, __pyx_k_A_uBd, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[197])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 548, 15};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self};
+    __pyx_mstate_global->__pyx_codeobj_tab[198] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_unicode, __pyx_k_A_wat81, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[198])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 551, 18};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self};
+    __pyx_mstate_global->__pyx_codeobj_tab[199] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_str, __pyx_k_A_Qd, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[199])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {0, 0, 0, 3, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 565, 78};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_table, __pyx_mstate->__pyx_n_u_groups, __pyx_mstate->__pyx_n_u_i};
+    __pyx_mstate_global->__pyx_codeobj_tab[200] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_ta_getGroupTable, __pyx_k_Q_B_1A_Q_V1E_gQfAU_Q_1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[200])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 4, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 577, 80};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_group, __pyx_mstate->__pyx_n_u_table, __pyx_mstate->__pyx_n_u_functions, __pyx_mstate->__pyx_n_u_i};
+    __pyx_mstate_global->__pyx_codeobj_tab[201] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_ta_getFuncTable, __pyx_k_Q_V1E_q_WAQ_Q_aq_1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[201])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 7, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 589, 166};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_flag, __pyx_mstate->__pyx_n_u_flags_lookup_dict, __pyx_mstate->__pyx_n_u_value_range, __pyx_mstate->__pyx_n_u_min_int, __pyx_mstate->__pyx_n_u_max_int, __pyx_mstate->__pyx_n_u_ret, __pyx_mstate->__pyx_n_u_i};
+    __pyx_mstate_global->__pyx_codeobj_tab[202] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_get_flags, __pyx_k_5_t_Qm1_d_1_c_d_3a_Q_c_d_3a_Q_u, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[202])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 3, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 648, 115};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_function_name, __pyx_mstate->__pyx_n_u_info, __pyx_mstate->__pyx_n_u_retCode};
+    __pyx_mstate_global->__pyx_codeobj_tab[203] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_ta_getFuncInfo, __pyx_k_314DAQ_Q_a_4q_a_Qd_c_a_Qd_s_4q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[203])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 5, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 667, 121};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_function_name, __pyx_mstate->__pyx_n_u_idx, __pyx_mstate->__pyx_n_u_info, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_name};
+    __pyx_mstate_global->__pyx_codeobj_tab[204] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_ta_getInputParameterInfo, __pyx_k_Q_NeSTTU_Q_2_9AT_4q_1G6_wc_t81H, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[204])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 6, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 688, 138};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_function_name, __pyx_mstate->__pyx_n_u_idx, __pyx_mstate->__pyx_n_u_info, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_name, __pyx_mstate->__pyx_n_u_default_value};
+    __pyx_mstate_global->__pyx_codeobj_tab[205] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_ta_getOptInputParameterInfo, __pyx_k_Q_AQQVVWWX_Q_5Q_9AT_4q_1JfA_Cq, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[205])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 5, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 710, 121};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_function_name, __pyx_mstate->__pyx_n_u_idx, __pyx_mstate->__pyx_n_u_info, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_name};
+    __pyx_mstate_global->__pyx_codeobj_tab[206] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_ta_getOutputParameterInfo, __pyx_k_1_a_OuTUUV_Q_31_9AT_4q_1HF_wc_d, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[206])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 730, 347};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_func_info, __pyx_mstate->__pyx_n_u_defaults, __pyx_mstate->__pyx_n_u_func_line, __pyx_mstate->__pyx_n_u_func_args, __pyx_mstate->__pyx_n_u_docs, __pyx_mstate->__pyx_n_u_input_names, __pyx_mstate->__pyx_n_u_input_name, __pyx_mstate->__pyx_n_u_value, __pyx_mstate->__pyx_n_u_params, __pyx_mstate->__pyx_n_u_param, __pyx_mstate->__pyx_n_u_outputs, __pyx_mstate->__pyx_n_u_output, __pyx_mstate->__pyx_n_u_documentation};
+    __pyx_mstate_global->__pyx_codeobj_tab[207] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__abstract_pxi, __pyx_mstate->__pyx_n_u_get_defaults_and_docs, __pyx_k_q_9A_1_q_1_1_1A_q_a_1A_4z_A_G1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[207])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 14, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 9, 209};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outrealupperband, __pyx_mstate->__pyx_n_u_outrealmiddleband, __pyx_mstate->__pyx_n_u_outreallowerband};
+    __pyx_mstate_global->__pyx_codeobj_tab[208] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_ACCBANDS, __pyx_k_fg2_aq_Q_Qa_y_1_Kq_q_6_a_q_q_Rv, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[208])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 7, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 50, 94};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[209] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_ACOS, __pyx_k_aq_Q_T_q_a_6_4vXRt_qP_llmmn_Qk, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[209])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 77, 181};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_volume, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_volume_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[210] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_AD, __pyx_k_aq_Q_Qa_y_1_Kq_q_6_6_gQ_a_r_xr, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[210])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 9, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 113, 115};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real0, __pyx_mstate->__pyx_n_u_real1, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real0_data, __pyx_mstate->__pyx_n_u_real1_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[211] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_ADD, __pyx_k_Kq_q_Kq_q_7_a_fHBd_iijjyyzz_Qj, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[211])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {6, 0, 0, 15, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 144, 214};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_volume, __pyx_mstate->__pyx_n_u_fastperiod, __pyx_mstate->__pyx_n_u_slowperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_volume_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[212] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_ADOSC, __pyx_k_A_Y_Y_Z_aq_Q_Qa_y_1_Kq_q_6_6_gQ, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[212])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 183, 164};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[213] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_ADX, __pyx_k_ab_aq_Q_Qa_y_1_Kq_q_6_a_a_fHBd, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[213])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 218, 164};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[214] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_ADXR, __pyx_k_bc_aq_Q_Qa_y_1_Kq_q_6_a_a_6_4vX, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[214])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 253, 124};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_fastperiod, __pyx_mstate->__pyx_n_u_slowperiod, __pyx_mstate->__pyx_n_u_matype, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[215] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_APO, __pyx_k_CC_aq_Q_T_q_a_fHBd_m_hhqqrr_O_O, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[215])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 11, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 284, 155};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outaroondown, __pyx_mstate->__pyx_n_u_outaroonup};
+    __pyx_mstate_global->__pyx_codeobj_tab[216] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_AROON, __pyx_k_GH_aq_Q_Qa_y_1_6_1_F_D_hb_LP_hh, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[216])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 319, 134};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[217] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_AROONOSC, __pyx_k_JK_aq_Q_Qa_y_1_6_a_RvXRt6_4_S_k, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[217])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 7, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 351, 94};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[218] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_ASIN, __pyx_k_aq_Q_T_q_a_6_4vXRt_qP_llmmn_Qk, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[218])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 7, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 378, 94};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[219] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_ATAN, __pyx_k_aq_Q_T_q_a_6_4vXRt_qP_llmmn_Qk, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[219])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 405, 164};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[220] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_ATR, __pyx_k_ab_aq_Q_Qa_y_1_Kq_q_6_a_a_fHBd, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[220])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 440, 182};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[221] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_AVGPRICE, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_a_Rv, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[221])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 8, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 476, 101};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[222] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_AVGDEV, __pyx_k_aq_Q_T_q_a_2V82T_xr_Q___kkll_Qm, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[222])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {5, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 505, 183};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_nbdevup, __pyx_mstate->__pyx_n_u_nbdevdn, __pyx_mstate->__pyx_n_u_matype, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outrealupperband, __pyx_mstate->__pyx_n_u_outrealmiddleband, __pyx_mstate->__pyx_n_u_outreallowerband};
+    __pyx_mstate_global->__pyx_codeobj_tab[223] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_BBANDS, __pyx_k_FF_ttu4_aq_Q_T_q_q_q_2V82T_xr_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[223])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 543, 134};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real0, __pyx_mstate->__pyx_n_u_real1, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real0_data, __pyx_mstate->__pyx_n_u_real1_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[224] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_BETA, __pyx_k_IJ_Kq_q_Kq_q_7_a_6_4vXRt_P_jjkk, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[224])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 576, 177};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[225] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_BOP, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_a_fH, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[225])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 612, 164};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[226] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CCI, __pyx_k_ab_aq_Q_Qa_y_1_Kq_q_6_a_a_fHBd, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[226])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 647, 183};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[227] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDL2CROWS, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_b_hb, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[227])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 683, 184};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[228] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDL3BLACKCROWS, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_2V82, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[228])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 719, 183};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[229] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDL3INSIDE, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_r_xr, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[229])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 755, 184};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[230] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDL3LINESTRIKE, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_2V82, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[230])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 791, 183};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[231] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDL3OUTSIDE, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_fHBd, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[231])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 827, 188};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[232] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDL3STARSINSOUTH, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_RvXR, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[232])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 863, 193};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[233] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDL3WHITESOLDIERS, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_b_hb_2, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[233])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {5, 0, 0, 14, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 899, 202};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_penetration, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[234] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLABANDONEDBABY, __pyx_k_J_K_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[234])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 937, 184};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[235] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLADVANCEBLOCK, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_BfHB, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[235])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 973, 183};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[236] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLBELTHOLD, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_fHBd, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[236])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1009, 184};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[237] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLBREAKAWAY, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_6_4v, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[237])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1045, 193};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[238] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLCLOSINGMARUBOZU, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_r_xr_2, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[238])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1081, 193};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[239] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLCONCEALBABYSWALL, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_fHBd_2, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[239])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1117, 188};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[240] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLCOUNTERATTACK, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_RvXR, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[240])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {5, 0, 0, 14, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1153, 207};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_penetration, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[241] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLDARKCLOUDCOVER, __pyx_k_K_L_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[241])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1191, 182};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[242] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLDOJI, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_BfHB_2, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[242])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1227, 183};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[243] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLDOJISTAR, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_fHBd, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[243])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1263, 188};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[244] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLDRAGONFLYDOJI, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_RvXR, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[244])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1299, 184};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[245] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLENGULFING, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_6_4v, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[245])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {5, 0, 0, 14, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1335, 207};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_penetration, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[246] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLEVENINGDOJISTAR, __pyx_k_L_M_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[246])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {5, 0, 0, 14, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1373, 202};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_penetration, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[247] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLEVENINGSTAR, __pyx_k_H_I_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[247])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1411, 193};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[248] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLGAPSIDESIDEWHITE, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_fHBd_2, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[248])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1447, 193};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[249] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLGRAVESTONEDOJI, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_b_hb_2, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[249])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1483, 183};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[250] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLHAMMER, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_b_hb, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[250])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1519, 184};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[251] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLHANGINGMAN, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_F_D, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[251])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1555, 183};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[252] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLHARAMI, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_b_hb, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[252])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1591, 184};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[253] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLHARAMICROSS, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_2V82, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[253])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1627, 183};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[254] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLHIGHWAVE, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_fHBd, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[254])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1663, 183};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[255] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLHIKKAKE, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_r_xr, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[255])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1699, 184};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[256] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLHIKKAKEMOD, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_F_D, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[256])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1735, 184};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[257] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLHOMINGPIGEON, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_BfHB, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[257])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1771, 193};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[258] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLIDENTICAL3CROWS, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_r_xr_2, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[258])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1807, 183};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[259] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLINNECK, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_b_hb, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[259])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1843, 193};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[260] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLINVERTEDHAMMER, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_b_hb_2, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[260])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1879, 183};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[261] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLKICKING, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_r_xr, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[261])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1915, 193};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[262] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLKICKINGBYLENGTH, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_r_xr_2, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[262])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1951, 184};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[263] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLLADDERBOTTOM, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_BfHB, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[263])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1987, 193};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[264] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLLONGLEGGEDDOJI, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_b_hb_2, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[264])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2023, 183};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[265] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLLONGLINE, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_fHBd, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[265])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2059, 183};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[266] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLMARUBOZU, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_fHBd, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[266])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2095, 184};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[267] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLMATCHINGLOW, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_2V82, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[267])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {5, 0, 0, 14, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2131, 201};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_penetration, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[268] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLMATHOLD, __pyx_k_D_E_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[268])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {5, 0, 0, 14, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2169, 207};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_penetration, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[269] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLMORNINGDOJISTAR, __pyx_k_L_M_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[269])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {5, 0, 0, 14, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2207, 202};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_penetration, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[270] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLMORNINGSTAR, __pyx_k_H_I_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[270])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2245, 183};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[271] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLONNECK, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_b_hb, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[271])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2281, 183};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[272] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLPIERCING, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_fHBd, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[272])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2317, 184};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[273] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLRICKSHAWMAN, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_2V82, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[273])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2353, 193};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[274] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLRISEFALL3METHODS, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_fHBd_2, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[274])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2389, 193};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[275] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLSEPARATINGLINES, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_r_xr_2, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[275])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2425, 184};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[276] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLSHOOTINGSTAR, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_BfHB, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[276])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2461, 184};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[277] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLSHORTLINE, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_6_4v, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[277])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2497, 184};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[278] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLSPINNINGTOP, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_2V82, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[278])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2533, 193};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[279] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLSTALLEDPATTERN, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_b_hb_2, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[279])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2569, 188};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[280] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLSTICKSANDWICH, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_RvXR, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[280])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2605, 183};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[281] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLTAKURI, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_b_hb, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[281])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2641, 184};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[282] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLTASUKIGAP, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_6_4v, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[282])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2677, 184};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[283] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLTHRUSTING, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_6_4v, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[283])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2713, 183};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[284] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLTRISTAR, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_r_xr, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[284])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2749, 184};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[285] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLUNIQUE3RIVER, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_BfHB, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[285])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2785, 193};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[286] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLUPSIDEGAP2CROWS, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_r_xr_2, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[286])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 13, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2821, 193};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[287] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CDLXSIDEGAP3METHODS, __pyx_k_aq_Q_aq_Q_Qa_y_1_Kq_q_6_uA_fHBd_2, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[287])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 7, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2857, 94};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[288] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CEIL, __pyx_k_aq_Q_T_q_a_6_4vXRt_qP_llmmn_Qk, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[288])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 8, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2884, 100};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[289] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CMO, __pyx_k_aq_Q_T_q_a_fHBd_m_hhiixxyyz_Qj, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[289])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2913, 134};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real0, __pyx_mstate->__pyx_n_u_real1, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real0_data, __pyx_mstate->__pyx_n_u_real1_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[290] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_CORREL, __pyx_k_KL_Kq_q_Kq_q_7_a_2V82T_xr_R__ll, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[290])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 7, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2946, 93};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[291] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_COS, __pyx_k_aq_Q_T_q_a_fHBd_a_kkllm_Qj_1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[291])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 7, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 2973, 94};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[292] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_COSH, __pyx_k_aq_Q_T_q_a_6_4vXRt_qP_llmmn_Qk, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[292])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 8, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3000, 100};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[293] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_DEMA, __pyx_k_aq_Q_T_q_a_6_4vXRt_iijjyyzz_Qk, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[293])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 9, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3029, 115};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real0, __pyx_mstate->__pyx_n_u_real1, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real0_data, __pyx_mstate->__pyx_n_u_real1_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[294] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_DIV, __pyx_k_Kq_q_Kq_q_7_a_fHBd_iijjyyzz_Qj, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[294])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3060, 160};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[295] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_DX, __pyx_k_a_aq_Q_Qa_y_1_Kq_q_6_a_a_r_xr_V, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[295])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 8, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3095, 100};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[296] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_EMA, __pyx_k_aq_Q_T_q_a_fHBd_m_hhiixxyyz_Qj, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[296])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 7, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3124, 93};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[297] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_EXP, __pyx_k_aq_Q_T_q_a_fHBd_a_kkllm_Qj_1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[297])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 7, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3151, 95};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[298] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_FLOOR, __pyx_k_aq_Q_T_q_a_F_D_hb_LPQQ_mmnno_Ql, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[298])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 7, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3178, 96};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[299] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_HT_DCPERIOD, __pyx_k_aq_Q_T_q_a_fHBd_VWWccddssttu_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[299])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 7, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3205, 96};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[300] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_HT_DCPHASE, __pyx_k_aq_Q_T_q_a_r_xr_V82T_UVVbbccrrs, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[300])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 8, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3232, 117};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinphase, __pyx_mstate->__pyx_n_u_outquadrature};
+    __pyx_mstate_global->__pyx_codeobj_tab[301] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_HT_PHASOR, __pyx_k_aq_Q_T_q_A_b_hb_F_D_TUUaabbqqrr, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[301])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 8, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3262, 108};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outsine, __pyx_mstate->__pyx_n_u_outleadsine};
+    __pyx_mstate_global->__pyx_codeobj_tab[302] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_HT_SINE, __pyx_k_aq_Q_T_q_a_BfHBd_lRSS___ooppzz, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[302])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 7, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3292, 97};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[303] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_HT_TRENDLINE, __pyx_k_aq_Q_T_q_a_6_4vXRt_WXXddeettuuv, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[303])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 7, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3319, 97};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[304] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_HT_TRENDMODE, __pyx_k_aq_Q_T_q_6_4vXRt_WXXddeettuuv_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[304])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3346, 133};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_open, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_open_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[305] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_IMI, __pyx_k_GH_aq_Q_Kq_q_6_a_fHBd_m_hhiiuuv, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[305])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 8, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3378, 100};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[306] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_KAMA, __pyx_k_aq_Q_T_q_a_6_4vXRt_iijjyyzz_Qk, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[306])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 8, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3407, 106};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[307] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_LINEARREG, __pyx_k_12_aq_Q_T_q_a_b_hb_F_D_Taabbnno, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[307])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 8, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3436, 115};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[308] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_LINEARREG_ANGLE, __pyx_k_78_aq_Q_T_q_a_BfHBd_lZgghhttu_v, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[308])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 8, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3465, 116};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[309] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_LINEARREG_INTERCEPT, __pyx_k_aq_Q_T_q_a_fHBdR_kkllxxy_z_I_I, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[309])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 8, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3494, 115};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[310] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_LINEARREG_SLOPE, __pyx_k_78_aq_Q_T_q_a_BfHBd_lZgghhttu_v, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[310])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 7, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3523, 93};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[311] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_LN, __pyx_k_aq_Q_T_q_a_r_xr_V82T_QlZ_jjkkl, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[311])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 7, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3550, 95};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[312] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_LOG10, __pyx_k_aq_Q_T_q_a_F_D_hb_LPQQ_mmnno_Ql, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[312])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 9, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3577, 117};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_matype, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[313] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_MA, __pyx_k_B_aq_Q_T_q_a_r_xr_V82T_Zccddppq, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[313])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3607, 175};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_fastperiod, __pyx_mstate->__pyx_n_u_slowperiod, __pyx_mstate->__pyx_n_u_signalperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outmacd, __pyx_mstate->__pyx_n_u_outmacdsignal, __pyx_mstate->__pyx_n_u_outmacdhist};
+    __pyx_mstate_global->__pyx_codeobj_tab[314] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_MACD, __pyx_k_DD_2_aq_Q_T_q_a_A_6_4vXRt_iixxy, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[314])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {7, 0, 0, 15, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3644, 222};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_fastperiod, __pyx_mstate->__pyx_n_u_fastmatype, __pyx_mstate->__pyx_n_u_slowperiod, __pyx_mstate->__pyx_n_u_slowmatype, __pyx_mstate->__pyx_n_u_signalperiod, __pyx_mstate->__pyx_n_u_signalmatype, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outmacd, __pyx_mstate->__pyx_n_u_outmacdsignal, __pyx_mstate->__pyx_n_u_outmacdhist};
+    __pyx_mstate_global->__pyx_codeobj_tab[315] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_MACDEXT, __pyx_k_GGZZr_s_F_F_a_8_aq_Q_T_q_a_A_Bf, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[315])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3684, 148};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_signalperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outmacd, __pyx_mstate->__pyx_n_u_outmacdsignal, __pyx_mstate->__pyx_n_u_outmacdhist};
+    __pyx_mstate_global->__pyx_codeobj_tab[316] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_MACDFIX, __pyx_k_0_aq_Q_T_q_a_A_BfHBd_lRaabbnnoo, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[316])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3719, 138};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_fastlimit, __pyx_mstate->__pyx_n_u_slowlimit, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outmama, __pyx_mstate->__pyx_n_u_outfama};
+    __pyx_mstate_global->__pyx_codeobj_tab[317] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_MAMA, __pyx_k_EQ_aq_Q_T_q_a_a_6_4vXRt_gghhttu, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[317])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {5, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3752, 157};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_periods, __pyx_mstate->__pyx_n_u_minperiod, __pyx_mstate->__pyx_n_u_maxperiod, __pyx_mstate->__pyx_n_u_matype, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_periods_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[318] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_MAVP, __pyx_k_Jaaxxy_aq_Q_k_9G1_6_a_6_4vXRt_j, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[318])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 8, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3787, 100};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[319] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_MAX, __pyx_k_aq_Q_T_q_a_fHBd_m_hhiixxyyz_Qj, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[319])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 8, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3816, 101};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[320] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_MAXINDEX, __pyx_k_01_aq_Q_T_q_RvXRt6_4_S_aammnn_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[320])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 9, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3845, 116};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[321] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_MEDPRICE, __pyx_k_aq_Q_Qa_y_1_6_a_RvXRt6_4_S___kk, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[321])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {5, 0, 0, 14, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3875, 195};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_volume, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_volume_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[322] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_MFI, __pyx_k_aq_Q_Qa_y_1_Kq_q_6_6_gQ_a_fHBd, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[322])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 8, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3913, 101};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[323] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_MIDPOINT, __pyx_k_01_aq_Q_T_q_a_RvXRt6_4_S_aammnn, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[323])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3942, 134};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[324] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_MIDPRICE, __pyx_k_JK_aq_Q_Qa_y_1_6_a_RvXRt6_4_S_k, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[324])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 8, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 3974, 100};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[325] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_MIN, __pyx_k_aq_Q_T_q_a_fHBd_m_hhiixxyyz_Qj, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[325])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 8, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4003, 101};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outinteger};
+    __pyx_mstate_global->__pyx_codeobj_tab[326] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_MININDEX, __pyx_k_01_aq_Q_T_q_RvXRt6_4_S_aammnn_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[326])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 9, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4032, 126};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outmin, __pyx_mstate->__pyx_n_u_outmax};
+    __pyx_mstate_global->__pyx_codeobj_tab[327] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_MINMAX, __pyx_k_aq_Q_T_q_Q_Q_2V82T_xr_Q___kkll, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[327])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 9, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4064, 135};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outminidx, __pyx_mstate->__pyx_n_u_outmaxidx};
+    __pyx_mstate_global->__pyx_codeobj_tab[328] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_MINMAXINDEX, __pyx_k_34_aq_Q_T_q_fHBd_Vccddppq_r_A_A, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[328])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4096, 165};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[329] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_MINUS_DI, __pyx_k_fg_aq_Q_Qa_y_1_Kq_q_6_a_a_RvXRt, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[329])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4131, 134};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[330] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_MINUS_DM, __pyx_k_JK_aq_Q_Qa_y_1_6_a_RvXRt6_4_S_k, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[330])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 8, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4163, 100};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[331] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_MOM, __pyx_k_aq_Q_T_q_a_fHBd_m_hhiixxyyz_Qj, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[331])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 9, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4192, 116};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real0, __pyx_mstate->__pyx_n_u_real1, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real0_data, __pyx_mstate->__pyx_n_u_real1_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[332] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_MULT, __pyx_k_Kq_q_Kq_q_7_a_6_4vXRt_P_jjkkzz, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[332])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4223, 164};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[333] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_NATR, __pyx_k_bc_aq_Q_Qa_y_1_Kq_q_6_a_a_6_4vX, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[333])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 9, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4258, 115};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_volume, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_volume_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[334] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_OBV, __pyx_k_aq_Q_6_6_a_fHBd_n_iijjyyzz_Qj_1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[334])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4289, 165};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[335] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_PLUS_DI, __pyx_k_ef_aq_Q_Qa_y_1_Kq_q_6_a_a_BfHBd, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[335])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4324, 134};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[336] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_PLUS_DM, __pyx_k_IJ_aq_Q_Qa_y_1_6_a_BfHBd_lR_jjk, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[336])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 10, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4356, 124};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_fastperiod, __pyx_mstate->__pyx_n_u_slowperiod, __pyx_mstate->__pyx_n_u_matype, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[337] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_PPO, __pyx_k_CC_aq_Q_T_q_a_fHBd_m_hhqqrr_O_O, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[337])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 8, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4387, 100};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[338] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_ROC, __pyx_k_aq_Q_T_q_a_fHBd_m_hhiixxyyz_Qj, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[338])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 8, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4416, 100};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[339] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_ROCP, __pyx_k_aq_Q_T_q_a_6_4vXRt_iijjyyzz_Qk, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[339])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 8, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4445, 100};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[340] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_ROCR, __pyx_k_aq_Q_T_q_a_6_4vXRt_iijjyyzz_Qk, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[340])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 8, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4474, 101};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[341] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_ROCR100, __pyx_k_0_aq_Q_T_q_a_BfHBd_lR___llmm_Qn, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[341])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 8, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4503, 100};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[342] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_RSI, __pyx_k_aq_Q_T_q_a_fHBd_m_hhiixxyyz_Qj, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[342])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 11, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4532, 143};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_acceleration, __pyx_mstate->__pyx_n_u_maximum, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[343] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_SAR, __pyx_k_E_a_aq_Q_Qa_y_1_6_a_fHBd_kYhhrr, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[343])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {10, 0, 0, 17, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4565, 240};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_startvalue, __pyx_mstate->__pyx_n_u_offsetonreverse, __pyx_mstate->__pyx_n_u_accelerationinitlong, __pyx_mstate->__pyx_n_u_accelerationlong, __pyx_mstate->__pyx_n_u_accelerationmaxlong, __pyx_mstate->__pyx_n_u_accelerationinitshort, __pyx_mstate->__pyx_n_u_accelerationshort, __pyx_mstate->__pyx_n_u_accelerationmaxshort, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[344] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_SAREXT, __pyx_k_Hb_c_B_B_f_f_F_F_i_i_N_N_o_o_p, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[344])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 7, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4604, 93};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[345] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_SIN, __pyx_k_aq_Q_T_q_a_fHBd_a_kkllm_Qj_1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[345])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 7, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4631, 94};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[346] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_SINH, __pyx_k_aq_Q_T_q_a_6_4vXRt_qP_llmmn_Qk, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[346])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 8, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4658, 100};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[347] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_SMA, __pyx_k_aq_Q_T_q_a_fHBd_m_hhiixxyyz_Qj, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[347])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 7, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4687, 94};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[348] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_SQRT, __pyx_k_aq_Q_T_q_a_6_4vXRt_qP_llmmn_Qk, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[348])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 9, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4714, 118};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_nbdev, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[349] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_STDDEV, __pyx_k_Fa_aq_Q_T_q_a_2V82T_xr_Q_ffggss, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[349])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {8, 0, 0, 17, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4744, 246};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_fastk_period, __pyx_mstate->__pyx_n_u_slowk_period, __pyx_mstate->__pyx_n_u_slowk_matype, __pyx_mstate->__pyx_n_u_slowd_period, __pyx_mstate->__pyx_n_u_slowd_matype, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outslowk, __pyx_mstate->__pyx_n_u_outslowd};
+    __pyx_mstate_global->__pyx_codeobj_tab[350] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_STOCH, __pyx_k_c_X_X_m_m_G_G_H_6_aq_Q_Qa_y_1_K, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[350])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {6, 0, 0, 15, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4786, 218};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_fastk_period, __pyx_mstate->__pyx_n_u_fastd_period, __pyx_mstate->__pyx_n_u_fastd_matype, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outfastk, __pyx_mstate->__pyx_n_u_outfastd};
+    __pyx_mstate_global->__pyx_codeobj_tab[351] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_STOCHF, __pyx_k_d_Y_Y_Z_2_aq_Q_Qa_y_1_Kq_q_6_a, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[351])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {5, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4826, 168};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_fastk_period, __pyx_mstate->__pyx_n_u_fastd_period, __pyx_mstate->__pyx_n_u_fastd_matype, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outfastk, __pyx_mstate->__pyx_n_u_outfastd};
+    __pyx_mstate_global->__pyx_codeobj_tab[352] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_STOCHRSI, __pyx_k_0HHbb_0_aq_Q_T_q_q_q_RvXRt6_4_S, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[352])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 9, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4861, 115};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real0, __pyx_mstate->__pyx_n_u_real1, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real0_data, __pyx_mstate->__pyx_n_u_real1_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[353] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_SUB, __pyx_k_Kq_q_Kq_q_7_a_fHBd_iijjyyzz_Qj, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[353])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 8, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4892, 100};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[354] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_SUM, __pyx_k_aq_Q_T_q_a_fHBd_m_hhiixxyyz_Qj, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[354])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 9, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4921, 117};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_vfactor, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[355] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_T3, __pyx_k_B_aq_Q_T_q_a_r_xr_V82T_Zddeeqqr, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[355])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 7, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4951, 93};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[356] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_TAN, __pyx_k_aq_Q_T_q_a_fHBd_a_kkllm_Qj_1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[356])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 7, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4978, 94};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[357] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_TANH, __pyx_k_aq_Q_T_q_a_6_4vXRt_qP_llmmn_Qk, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[357])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 8, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 5005, 100};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[358] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_TEMA, __pyx_k_aq_Q_T_q_a_6_4vXRt_iijjyyzz_Qk, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[358])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 11, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 5034, 151};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[359] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_TRANGE, __pyx_k_aq_Q_Qa_y_1_Kq_q_6_a_a_2V82T_xr, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[359])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 8, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 5067, 101};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[360] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_TRIMA, __pyx_k_aq_Q_T_q_a_F_D_hb_LP_jjkkzz_Ql, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[360])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 8, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 5096, 100};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[361] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_TRIX, __pyx_k_aq_Q_T_q_a_6_4vXRt_iijjyyzz_Qk, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[361])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 8, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 5125, 100};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[362] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_TSF, __pyx_k_aq_Q_T_q_a_fHBd_m_hhiixxyyz_Qj, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[362])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 11, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 5154, 151};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[363] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_TYPPRICE, __pyx_k_aq_Q_Qa_y_1_Kq_q_6_a_a_RvXRt6_4, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[363])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {6, 0, 0, 14, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 5187, 197};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_timeperiod1, __pyx_mstate->__pyx_n_u_timeperiod2, __pyx_mstate->__pyx_n_u_timeperiod3, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[364] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_ULTOSC, __pyx_k_d_W_W_X_aq_Q_Qa_y_1_Kq_q_6_a_a, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[364])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 9, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 5224, 117};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_nbdev, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[365] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_VAR, __pyx_k_C1_aq_Q_T_q_a_fHBd_m_ccddppq_r, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[365])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 11, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 5254, 151};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[366] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_WCLPRICE, __pyx_k_aq_Q_Qa_y_1_Kq_q_6_a_a_RvXRt6_4, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[366])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {4, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 5287, 165};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_high, __pyx_mstate->__pyx_n_u_low, __pyx_mstate->__pyx_n_u_close, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_high_data, __pyx_mstate->__pyx_n_u_low_data, __pyx_mstate->__pyx_n_u_close_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[367] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_WILLR, __pyx_k_cd_aq_Q_Qa_y_1_Kq_q_6_a_a_F_D_h, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[367])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 8, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 5322, 100};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_real, __pyx_mstate->__pyx_n_u_timeperiod, __pyx_mstate->__pyx_n_u_length, __pyx_mstate->__pyx_n_u_retCode, __pyx_mstate->__pyx_n_u_real_data, __pyx_mstate->__pyx_n_u_outbegidx, __pyx_mstate->__pyx_n_u_outnbelement, __pyx_mstate->__pyx_n_u_outreal};
+    __pyx_mstate_global->__pyx_codeobj_tab[368] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_talib__stream_pxi, __pyx_mstate->__pyx_n_u_stream_WMA, __pyx_k_aq_Q_T_q_a_fHBd_m_hhiixxyyz_Qj, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[368])) goto bad;
+  }
+  Py_DECREF(tuple_dedup_map);
+  return 0;
+  bad:
+  Py_DECREF(tuple_dedup_map);
+  return -1;
+}
+/* #### Code section: init_globals ### */
 
-  goto __pyx_L0;
+static int __Pyx_InitGlobals(void) {
+  /* PythonCompatibility.init */
+  if (likely(__Pyx_init_co_variables() == 0)); else
+
+if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L1_error)
+
+  /* CachedMethodType.init */
+  #if CYTHON_COMPILING_IN_LIMITED_API
+{
+    PyObject *typesModule=NULL;
+    typesModule = PyImport_ImportModule("types");
+    if (typesModule) {
+        __pyx_mstate_global->__Pyx_CachedMethodType = PyObject_GetAttrString(typesModule, "MethodType");
+        Py_DECREF(typesModule);
+    }
+} // error handling follows
+#endif
+
+if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L1_error)
+
+  return 0;
   __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_6);
-  __Pyx_XDECREF(__pyx_t_7);
-  __Pyx_XDECREF(__pyx_t_8);
-  __Pyx_XDECREF(__pyx_t_9);
-  __Pyx_XDECREF(__pyx_t_10);
-  __Pyx_XDECREF(__pyx_t_11);
-  __Pyx_XDECREF(__pyx_t_12);
-  __Pyx_XDECREF(__pyx_t_13);
-  __Pyx_XDECREF(__pyx_t_16);
-  __Pyx_XDECREF(__pyx_t_17);
-  __Pyx_XDECREF(__pyx_t_18);
-  if (__pyx_m) {
-    if (__pyx_d) {
-      __Pyx_AddTraceback("init talib._ta_lib", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  return -1;
+}
+/* #### Code section: cleanup_globals ### */
+/* #### Code section: cleanup_module ### */
+/* #### Code section: main_method ### */
+/* #### Code section: utility_code_pragmas ### */
+#ifdef _MSC_VER
+#pragma warning( push )
+/* Warning 4127: conditional expression is constant
+ * Cython uses constant conditional expressions to allow in inline functions to be optimized at
+ * compile-time, so this warning is not useful
+ */
+#pragma warning( disable : 4127 )
+#endif
+
+
+
+/* #### Code section: utility_code_def ### */
+
+/* --- 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(modname);
+    if (!m) goto end;
+    p = PyObject_GetAttrString(m, "RefNannyAPI");
+    if (!p) goto end;
+    r = PyLong_AsVoidPtr(p);
+end:
+    Py_XDECREF(p);
+    Py_XDECREF(m);
+    return (__Pyx_RefNannyAPIStruct *)r;
+}
+#endif
+
+/* PyErrExceptionMatches */
+#if CYTHON_FAST_THREAD_STATE
+static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) {
+    Py_ssize_t i, n;
+    n = PyTuple_GET_SIZE(tuple);
+    for (i=0; i<n; i++) {
+        if (exc_type == PyTuple_GET_ITEM(tuple, i)) return 1;
     }
-    Py_CLEAR(__pyx_m);
-  } else if (!PyErr_Occurred()) {
-    PyErr_SetString(PyExc_ImportError, "init talib._ta_lib");
-  }
-  __pyx_L0:;
-  __Pyx_RefNannyFinishContext();
-  #if CYTHON_PEP489_MULTI_PHASE_INIT
-  return (__pyx_m != NULL) ? 0 : -1;
-  #elif PY_MAJOR_VERSION >= 3
-  return __pyx_m;
+    for (i=0; i<n; i++) {
+        if (__Pyx_PyErr_GivenExceptionMatches(exc_type, PyTuple_GET_ITEM(tuple, i))) return 1;
+    }
+    return 0;
+}
+static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err) {
+    int result;
+    PyObject *exc_type;
+#if PY_VERSION_HEX >= 0x030C00A6
+    PyObject *current_exception = tstate->current_exception;
+    if (unlikely(!current_exception)) return 0;
+    exc_type = (PyObject*) Py_TYPE(current_exception);
+    if (exc_type == err) return 1;
+#else
+    exc_type = tstate->curexc_type;
+    if (exc_type == err) return 1;
+    if (unlikely(!exc_type)) return 0;
+#endif
+    #if CYTHON_AVOID_BORROWED_REFS
+    Py_INCREF(exc_type);
+    #endif
+    if (unlikely(PyTuple_Check(err))) {
+        result = __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err);
+    } else {
+        result = __Pyx_PyErr_GivenExceptionMatches(exc_type, err);
+    }
+    #if CYTHON_AVOID_BORROWED_REFS
+    Py_DECREF(exc_type);
+    #endif
+    return result;
+}
+#endif
+
+/* PyErrFetchRestore */
+#if CYTHON_FAST_THREAD_STATE
+static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) {
+#if PY_VERSION_HEX >= 0x030C00A6
+    PyObject *tmp_value;
+    assert(type == NULL || (value != NULL && type == (PyObject*) Py_TYPE(value)));
+    if (value) {
+        #if CYTHON_COMPILING_IN_CPYTHON
+        if (unlikely(((PyBaseExceptionObject*) value)->traceback != tb))
+        #endif
+            PyException_SetTraceback(value, tb);
+    }
+    tmp_value = tstate->current_exception;
+    tstate->current_exception = value;
+    Py_XDECREF(tmp_value);
+    Py_XDECREF(type);
+    Py_XDECREF(tb);
+#else
+    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);
+#endif
+}
+static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) {
+#if PY_VERSION_HEX >= 0x030C00A6
+    PyObject* exc_value;
+    exc_value = tstate->current_exception;
+    tstate->current_exception = 0;
+    *value = exc_value;
+    *type = NULL;
+    *tb = NULL;
+    if (exc_value) {
+        *type = (PyObject*) Py_TYPE(exc_value);
+        Py_INCREF(*type);
+        #if CYTHON_COMPILING_IN_CPYTHON
+        *tb = ((PyBaseExceptionObject*) exc_value)->traceback;
+        Py_XINCREF(*tb);
+        #else
+        *tb = PyException_GetTraceback(exc_value);
+        #endif
+    }
+#else
+    *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
+}
+#endif
+
+/* PyObjectGetAttrStr */
+#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);
+    return PyObject_GetAttr(obj, attr_name);
+}
+#endif
+
+/* PyObjectGetAttrStrNoError */
+#if __PYX_LIMITED_VERSION_HEX < 0x030d0000
+static void __Pyx_PyObject_GetAttrStr_ClearAttributeError(void) {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    if (likely(__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError)))
+        __Pyx_PyErr_Clear();
+}
+#endif
+static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name) {
+    PyObject *result;
+#if __PYX_LIMITED_VERSION_HEX >= 0x030d0000
+    (void) PyObject_GetOptionalAttr(obj, attr_name, &result);
+    return result;
+#else
+#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_TYPE_SLOTS
+    PyTypeObject* tp = Py_TYPE(obj);
+    if (likely(tp->tp_getattro == PyObject_GenericGetAttr)) {
+        return _PyObject_GenericGetAttrWithDict(obj, attr_name, NULL, 1);
+    }
+#endif
+    result = __Pyx_PyObject_GetAttrStr(obj, attr_name);
+    if (unlikely(!result)) {
+        __Pyx_PyObject_GetAttrStr_ClearAttributeError();
+    }
+    return result;
+#endif
+}
+
+/* GetBuiltinName */
+static PyObject *__Pyx_GetBuiltinName(PyObject *name) {
+    PyObject* result = __Pyx_PyObject_GetAttrStrNoError(__pyx_mstate_global->__pyx_b, name);
+    if (unlikely(!result) && !PyErr_Occurred()) {
+        PyErr_Format(PyExc_NameError,
+            "name '%U' is not defined", name);
+    }
+    return result;
+}
+
+/* GetTopmostException */
+#if CYTHON_USE_EXC_INFO_STACK && CYTHON_FAST_THREAD_STATE
+static _PyErr_StackItem *
+__Pyx_PyErr_GetTopmostException(PyThreadState *tstate)
+{
+    _PyErr_StackItem *exc_info = tstate->exc_info;
+    while ((exc_info->exc_value == NULL || exc_info->exc_value == Py_None) &&
+           exc_info->previous_item != NULL)
+    {
+        exc_info = exc_info->previous_item;
+    }
+    return exc_info;
+}
+#endif
+
+/* SaveResetException */
+#if CYTHON_FAST_THREAD_STATE
+static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) {
+  #if CYTHON_USE_EXC_INFO_STACK && PY_VERSION_HEX >= 0x030B00a4
+    _PyErr_StackItem *exc_info = __Pyx_PyErr_GetTopmostException(tstate);
+    PyObject *exc_value = exc_info->exc_value;
+    if (exc_value == NULL || exc_value == Py_None) {
+        *value = NULL;
+        *type = NULL;
+        *tb = NULL;
+    } else {
+        *value = exc_value;
+        Py_INCREF(*value);
+        *type = (PyObject*) Py_TYPE(exc_value);
+        Py_INCREF(*type);
+        *tb = PyException_GetTraceback(exc_value);
+    }
+  #elif CYTHON_USE_EXC_INFO_STACK
+    _PyErr_StackItem *exc_info = __Pyx_PyErr_GetTopmostException(tstate);
+    *type = exc_info->exc_type;
+    *value = exc_info->exc_value;
+    *tb = exc_info->exc_traceback;
+    Py_XINCREF(*type);
+    Py_XINCREF(*value);
+    Py_XINCREF(*tb);
+  #else
+    *type = tstate->exc_type;
+    *value = tstate->exc_value;
+    *tb = tstate->exc_traceback;
+    Py_XINCREF(*type);
+    Py_XINCREF(*value);
+    Py_XINCREF(*tb);
+  #endif
+}
+static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) {
+  #if CYTHON_USE_EXC_INFO_STACK && PY_VERSION_HEX >= 0x030B00a4
+    _PyErr_StackItem *exc_info = tstate->exc_info;
+    PyObject *tmp_value = exc_info->exc_value;
+    exc_info->exc_value = value;
+    Py_XDECREF(tmp_value);
+    Py_XDECREF(type);
+    Py_XDECREF(tb);
   #else
-  return;
+    PyObject *tmp_type, *tmp_value, *tmp_tb;
+    #if CYTHON_USE_EXC_INFO_STACK
+    _PyErr_StackItem *exc_info = tstate->exc_info;
+    tmp_type = exc_info->exc_type;
+    tmp_value = exc_info->exc_value;
+    tmp_tb = exc_info->exc_traceback;
+    exc_info->exc_type = type;
+    exc_info->exc_value = value;
+    exc_info->exc_traceback = tb;
+    #else
+    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;
+    #endif
+    Py_XDECREF(tmp_type);
+    Py_XDECREF(tmp_value);
+    Py_XDECREF(tmp_tb);
   #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(modname);
-    if (!m) goto end;
-    p = PyObject_GetAttrString(m, "RefNannyAPI");
-    if (!p) goto end;
-    r = PyLong_AsVoidPtr(p);
-end:
-    Py_XDECREF(p);
-    Py_XDECREF(m);
-    return (__Pyx_RefNannyAPIStruct *)r;
-}
 #endif
 
-/* PyObjectGetAttrStr */
-#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));
+/* 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
-    return PyObject_GetAttr(obj, attr_name);
-}
+{
+    PyObject *local_type = NULL, *local_value, *local_tb = NULL;
+#if CYTHON_FAST_THREAD_STATE
+    PyObject *tmp_type, *tmp_value, *tmp_tb;
+  #if PY_VERSION_HEX >= 0x030C0000
+    local_value = tstate->current_exception;
+    tstate->current_exception = 0;
+  #else
+    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;
+  #endif
+#elif __PYX_LIMITED_VERSION_HEX > 0x030C0000
+    local_value = PyErr_GetRaisedException();
+#else
+    PyErr_Fetch(&local_type, &local_value, &local_tb);
 #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);
+#if __PYX_LIMITED_VERSION_HEX > 0x030C0000
+    if (likely(local_value)) {
+        local_type = (PyObject*) Py_TYPE(local_value);
+        Py_INCREF(local_type);
+        local_tb = PyException_GetTraceback(local_value);
+    }
+#else
+    PyErr_NormalizeException(&local_type, &local_value, &local_tb);
+#if CYTHON_FAST_THREAD_STATE
+    if (unlikely(tstate->curexc_type))
 #else
-            "name '%.200s' is not defined", PyString_AS_STRING(name));
+    if (unlikely(PyErr_Occurred()))
 #endif
+        goto bad;
+    if (local_tb) {
+        if (unlikely(PyException_SetTraceback(local_value, local_tb) < 0))
+            goto bad;
     }
-    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);
-    int flags = PyCFunction_GET_FLAGS(func);
-    assert(PyCFunction_Check(func));
-    assert(METH_FASTCALL == (flags & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS)));
-    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());
-    if ((PY_VERSION_HEX < 0x030700A0) || unlikely(flags & METH_KEYWORDS)) {
-        return (*((__Pyx_PyCFunctionFastWithKeywords)(void*)meth)) (self, args, nargs, NULL);
-    } else {
-        return (*((__Pyx_PyCFunctionFast)(void*)meth)) (self, args, nargs);
+#endif // __PYX_LIMITED_VERSION_HEX > 0x030C0000
+    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
+    #if CYTHON_USE_EXC_INFO_STACK
+    {
+        _PyErr_StackItem *exc_info = tstate->exc_info;
+      #if PY_VERSION_HEX >= 0x030B00a4
+        tmp_value = exc_info->exc_value;
+        exc_info->exc_value = local_value;
+        tmp_type = NULL;
+        tmp_tb = NULL;
+        Py_XDECREF(local_type);
+        Py_XDECREF(local_tb);
+      #else
+        tmp_type = exc_info->exc_type;
+        tmp_value = exc_info->exc_value;
+        tmp_tb = exc_info->exc_traceback;
+        exc_info->exc_type = local_type;
+        exc_info->exc_value = local_value;
+        exc_info->exc_traceback = local_tb;
+      #endif
     }
-}
+    #else
+    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;
+    #endif
+    Py_XDECREF(tmp_type);
+    Py_XDECREF(tmp_value);
+    Py_XDECREF(tmp_tb);
+#elif __PYX_LIMITED_VERSION_HEX >= 0x030b0000
+    PyErr_SetHandledException(local_value);
+    Py_XDECREF(local_value);
+    Py_XDECREF(local_type);
+    Py_XDECREF(local_tb);
+#else
+    PyErr_SetExcInfo(local_type, local_value, local_tb);
+#endif
+    return 0;
+#if __PYX_LIMITED_VERSION_HEX <= 0x030C0000
+bad:
+    *type = 0;
+    *value = 0;
+    *tb = 0;
+    Py_XDECREF(local_type);
+    Py_XDECREF(local_value);
+    Py_XDECREF(local_tb);
+    return -1;
 #endif
+}
 
 /* PyFunctionFastCall */
-#if CYTHON_FAST_PYCALL
-static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject **args, Py_ssize_t na,
+#if CYTHON_FAST_PYCALL && !CYTHON_VECTORCALL
+static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject *const *args, Py_ssize_t na,
                                                PyObject *globals) {
     PyFrameObject *f;
     PyThreadState *tstate = __Pyx_PyThreadState_Current;
@@ -70123,15 +90301,12 @@ static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject **args
     --tstate->recursion_depth;
     return result;
 }
-#if 1 || PY_VERSION_HEX < 0x030600B1
-static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, int nargs, PyObject *kwargs) {
+static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject *const *args, Py_ssize_t 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;
@@ -70139,13 +90314,11 @@ static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args,
     PyObject *result;
     assert(kwargs == NULL || PyDict_Check(kwargs));
     nk = kwargs ? PyDict_Size(kwargs) : 0;
-    if (Py_EnterRecursiveCall((char*)" while calling a Python object")) {
+    if (unlikely(Py_EnterRecursiveCall(" 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) {
@@ -70182,9 +90355,7 @@ static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args,
         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);
@@ -70193,33 +90364,25 @@ static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args,
         d = NULL;
         nd = 0;
     }
-#if PY_MAJOR_VERSION >= 3
     result = PyEval_EvalCodeEx((PyObject*)co, globals, (PyObject *)NULL,
-                               args, nargs,
+                               args, (int)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
-#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;
+    ternaryfunc call = Py_TYPE(func)->tp_call;
     if (unlikely(!call))
         return PyObject_Call(func, arg, kw);
-    if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object")))
+    if (unlikely(Py_EnterRecursiveCall(" while calling a Python object")))
         return NULL;
     result = (*call)(func, arg, kw);
     Py_LeaveRecursiveCall();
@@ -70228,252 +90391,1097 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg
             PyExc_SystemError,
             "NULL result without error in PyObject_Call");
     }
-    return result;
-}
+    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 = __Pyx_CyOrPyCFunction_GET_FUNCTION(func);
+    self = __Pyx_CyOrPyCFunction_GET_SELF(func);
+    if (unlikely(Py_EnterRecursiveCall(" 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
+
+/* PyObjectFastCall */
+#if PY_VERSION_HEX < 0x03090000 || CYTHON_COMPILING_IN_LIMITED_API
+static PyObject* __Pyx_PyObject_FastCall_fallback(PyObject *func, PyObject * const*args, size_t nargs, PyObject *kwargs) {
+    PyObject *argstuple;
+    PyObject *result = 0;
+    size_t i;
+    argstuple = PyTuple_New((Py_ssize_t)nargs);
+    if (unlikely(!argstuple)) return NULL;
+    for (i = 0; i < nargs; i++) {
+        Py_INCREF(args[i]);
+        if (__Pyx_PyTuple_SET_ITEM(argstuple, (Py_ssize_t)i, args[i]) != (0)) goto bad;
+    }
+    result = __Pyx_PyObject_Call(func, argstuple, kwargs);
+  bad:
+    Py_DECREF(argstuple);
+    return result;
+}
+#endif
+#if CYTHON_VECTORCALL && !CYTHON_COMPILING_IN_LIMITED_API
+  #if PY_VERSION_HEX < 0x03090000
+    #define __Pyx_PyVectorcall_Function(callable) _PyVectorcall_Function(callable)
+  #elif CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE vectorcallfunc __Pyx_PyVectorcall_Function(PyObject *callable) {
+    PyTypeObject *tp = Py_TYPE(callable);
+    #if defined(__Pyx_CyFunction_USED)
+    if (__Pyx_CyFunction_CheckExact(callable)) {
+        return __Pyx_CyFunction_func_vectorcall(callable);
+    }
+    #endif
+    if (!PyType_HasFeature(tp, Py_TPFLAGS_HAVE_VECTORCALL)) {
+        return NULL;
+    }
+    assert(PyCallable_Check(callable));
+    Py_ssize_t offset = tp->tp_vectorcall_offset;
+    assert(offset > 0);
+    vectorcallfunc ptr;
+    memcpy(&ptr, (char *) callable + offset, sizeof(ptr));
+    return ptr;
+}
+  #else
+    #define __Pyx_PyVectorcall_Function(callable) PyVectorcall_Function(callable)
+  #endif
+#endif
+static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject *const *args, size_t _nargs, PyObject *kwargs) {
+    Py_ssize_t nargs = __Pyx_PyVectorcall_NARGS(_nargs);
+#if CYTHON_COMPILING_IN_CPYTHON
+    if (nargs == 0 && kwargs == NULL) {
+        if (__Pyx_CyOrPyCFunction_Check(func) && likely( __Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_NOARGS))
+            return __Pyx_PyObject_CallMethO(func, NULL);
+    }
+    else if (nargs == 1 && kwargs == NULL) {
+        if (__Pyx_CyOrPyCFunction_Check(func) && likely( __Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_O))
+            return __Pyx_PyObject_CallMethO(func, args[0]);
+    }
+#endif
+    #if PY_VERSION_HEX < 0x030800B1
+    #if CYTHON_FAST_PYCCALL
+    if (PyCFunction_Check(func)) {
+        if (kwargs) {
+            return _PyCFunction_FastCallDict(func, args, nargs, kwargs);
+        } else {
+            return _PyCFunction_FastCallKeywords(func, args, nargs, NULL);
+        }
+    }
+    if (!kwargs && __Pyx_IS_TYPE(func, &PyMethodDescr_Type)) {
+        return _PyMethodDescr_FastCallKeywords(func, args, nargs, NULL);
+    }
+    #endif
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(func)) {
+        return __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs);
+    }
+    #endif
+    #endif
+    if (kwargs == NULL) {
+        #if CYTHON_VECTORCALL && !CYTHON_COMPILING_IN_LIMITED_API
+        vectorcallfunc f = __Pyx_PyVectorcall_Function(func);
+        if (f) {
+            return f(func, args, _nargs, NULL);
+        }
+        #elif defined(__Pyx_CyFunction_USED) && CYTHON_BACKPORT_VECTORCALL
+        if (__Pyx_CyFunction_CheckExact(func)) {
+            __pyx_vectorcallfunc f = __Pyx_CyFunction_func_vectorcall(func);
+            if (f) return f(func, args, _nargs, NULL);
+        }
+        #elif CYTHON_COMPILING_IN_LIMITED_API && CYTHON_VECTORCALL
+        return PyObject_Vectorcall(func, args, _nargs, NULL);
+        #endif
+    }
+    if (nargs == 0) {
+        return __Pyx_PyObject_Call(func, __pyx_mstate_global->__pyx_empty_tuple, kwargs);
+    }
+    #if PY_VERSION_HEX >= 0x03090000 && !CYTHON_COMPILING_IN_LIMITED_API
+    return PyObject_VectorcallDict(func, args, (size_t)nargs, kwargs);
+    #else
+    return __Pyx_PyObject_FastCall_fallback(func, args, (size_t)nargs, kwargs);
+    #endif
+}
+
+/* RaiseException */
+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 (cause) {
+        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 PY_VERSION_HEX >= 0x030C00A6
+        PyException_SetTraceback(value, tb);
+#elif CYTHON_FAST_THREAD_STATE
+        PyThreadState *tstate = __Pyx_PyThreadState_Current;
+        PyObject* tmp_tb = tstate->curexc_traceback;
+        if (tb != tmp_tb) {
+            Py_INCREF(tb);
+            tstate->curexc_traceback = tb;
+            Py_XDECREF(tmp_tb);
+        }
+#else
+        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);
+#endif
+    }
+bad:
+    Py_XDECREF(owned_instance);
+    return;
+}
+
+/* PyUnicode_Unicode */
+static CYTHON_INLINE PyObject* __Pyx_PyUnicode_Unicode(PyObject *obj) {
+    if (unlikely(obj == Py_None))
+        obj = __pyx_mstate_global->__pyx_kp_u_None;
+    return __Pyx_NewRef(obj);
+}
+
+/* PyObjectFormatAndDecref */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_FormatSimpleAndDecref(PyObject* s, PyObject* f) {
+    if (unlikely(!s)) return NULL;
+    if (likely(PyUnicode_CheckExact(s))) return s;
+    return __Pyx_PyObject_FormatAndDecref(s, f);
+}
+static CYTHON_INLINE PyObject* __Pyx_PyObject_FormatAndDecref(PyObject* s, PyObject* f) {
+    PyObject *result;
+    if (unlikely(!s)) return NULL;
+    result = PyObject_Format(s, f);
+    Py_DECREF(s);
+    return result;
+}
+
+/* JoinPyUnicode */
+static PyObject* __Pyx_PyUnicode_Join(PyObject** values, Py_ssize_t value_count, Py_ssize_t result_ulength,
+                                      Py_UCS4 max_char) {
+#if CYTHON_USE_UNICODE_INTERNALS && CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+    PyObject *result_uval;
+    int result_ukind, kind_shift;
+    Py_ssize_t i, char_pos;
+    void *result_udata;
+    if (max_char > 1114111) max_char = 1114111;
+    result_uval = PyUnicode_New(result_ulength, max_char);
+    if (unlikely(!result_uval)) return NULL;
+    result_ukind = (max_char <= 255) ? PyUnicode_1BYTE_KIND : (max_char <= 65535) ? PyUnicode_2BYTE_KIND : PyUnicode_4BYTE_KIND;
+    kind_shift = (result_ukind == PyUnicode_4BYTE_KIND) ? 2 : result_ukind - 1;
+    result_udata = PyUnicode_DATA(result_uval);
+    assert(kind_shift == 2 || kind_shift == 1 || kind_shift == 0);
+    if (unlikely((PY_SSIZE_T_MAX >> kind_shift) - result_ulength < 0))
+        goto overflow;
+    char_pos = 0;
+    for (i=0; i < value_count; i++) {
+        int ukind;
+        Py_ssize_t ulength;
+        void *udata;
+        PyObject *uval = values[i];
+        #if !CYTHON_COMPILING_IN_LIMITED_API
+        if (__Pyx_PyUnicode_READY(uval) == (-1))
+            goto bad;
+        #endif
+        ulength = __Pyx_PyUnicode_GET_LENGTH(uval);
+        #if !CYTHON_ASSUME_SAFE_SIZE
+        if (unlikely(ulength < 0)) goto bad;
+        #endif
+        if (unlikely(!ulength))
+            continue;
+        if (unlikely((PY_SSIZE_T_MAX >> kind_shift) - ulength < char_pos))
+            goto overflow;
+        ukind = __Pyx_PyUnicode_KIND(uval);
+        udata = __Pyx_PyUnicode_DATA(uval);
+        if (ukind == result_ukind) {
+            memcpy((char *)result_udata + (char_pos << kind_shift), udata, (size_t) (ulength << kind_shift));
+        } else {
+            #if PY_VERSION_HEX >= 0x030d0000
+            if (unlikely(PyUnicode_CopyCharacters(result_uval, char_pos, uval, 0, ulength) < 0)) goto bad;
+            #elif CYTHON_COMPILING_IN_CPYTHON || defined(_PyUnicode_FastCopyCharacters)
+            _PyUnicode_FastCopyCharacters(result_uval, char_pos, uval, 0, ulength);
+            #else
+            Py_ssize_t j;
+            for (j=0; j < ulength; j++) {
+                Py_UCS4 uchar = __Pyx_PyUnicode_READ(ukind, udata, j);
+                __Pyx_PyUnicode_WRITE(result_ukind, result_udata, char_pos+j, uchar);
+            }
+            #endif
+        }
+        char_pos += ulength;
+    }
+    return result_uval;
+overflow:
+    PyErr_SetString(PyExc_OverflowError, "join() result is too long for a Python string");
+bad:
+    Py_DECREF(result_uval);
+    return NULL;
+#else
+    Py_ssize_t i;
+    PyObject *result = NULL;
+    PyObject *value_tuple = PyTuple_New(value_count);
+    if (unlikely(!value_tuple)) return NULL;
+    CYTHON_UNUSED_VAR(max_char);
+    CYTHON_UNUSED_VAR(result_ulength);
+    for (i=0; i<value_count; i++) {
+        if (__Pyx_PyTuple_SET_ITEM(value_tuple, i, values[i]) != (0)) goto bad;
+        Py_INCREF(values[i]);
+    }
+    result = PyUnicode_Join(__pyx_mstate_global->__pyx_empty_unicode, value_tuple);
+bad:
+    Py_DECREF(value_tuple);
+    return result;
+#endif
+}
+
+/* TupleAndListFromArray */
+#if !CYTHON_COMPILING_IN_CPYTHON && CYTHON_METH_FASTCALL
+static CYTHON_INLINE PyObject *
+__Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n)
+{
+    PyObject *res;
+    Py_ssize_t i;
+    if (n <= 0) {
+        return __Pyx_NewRef(__pyx_mstate_global->__pyx_empty_tuple);
+    }
+    res = PyTuple_New(n);
+    if (unlikely(res == NULL)) return NULL;
+    for (i = 0; i < n; i++) {
+        if (unlikely(__Pyx_PyTuple_SET_ITEM(res, i, src[i]) < (0))) {
+            Py_DECREF(res);
+            return NULL;
+        }
+        Py_INCREF(src[i]);
+    }
+    return res;
+}
+#elif CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE void __Pyx_copy_object_array(PyObject *const *CYTHON_RESTRICT src, PyObject** CYTHON_RESTRICT dest, Py_ssize_t length) {
+    PyObject *v;
+    Py_ssize_t i;
+    for (i = 0; i < length; i++) {
+        v = dest[i] = src[i];
+        Py_INCREF(v);
+    }
+}
+static CYTHON_INLINE PyObject *
+__Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n)
+{
+    PyObject *res;
+    if (n <= 0) {
+        return __Pyx_NewRef(__pyx_mstate_global->__pyx_empty_tuple);
+    }
+    res = PyTuple_New(n);
+    if (unlikely(res == NULL)) return NULL;
+    __Pyx_copy_object_array(src, ((PyTupleObject*)res)->ob_item, n);
+    return res;
+}
+static CYTHON_INLINE PyObject *
+__Pyx_PyList_FromArray(PyObject *const *src, Py_ssize_t n)
+{
+    PyObject *res;
+    if (n <= 0) {
+        return PyList_New(0);
+    }
+    res = PyList_New(n);
+    if (unlikely(res == NULL)) return NULL;
+    __Pyx_copy_object_array(src, ((PyListObject*)res)->ob_item, n);
+    return res;
+}
+#endif
+
+/* BytesEquals */
+static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals) {
+#if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_GRAAL ||\
+        !(CYTHON_ASSUME_SAFE_SIZE && CYTHON_ASSUME_SAFE_MACROS)
+    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;
+#if CYTHON_USE_UNICODE_INTERNALS && (PY_VERSION_HEX < 0x030B0000)
+            Py_hash_t hash1, hash2;
+            hash1 = ((PyBytesObject*)s1)->ob_shash;
+            hash2 = ((PyBytesObject*)s2)->ob_shash;
+            if (hash1 != hash2 && hash1 != -1 && hash2 != -1) {
+                return (equals == Py_NE);
+            }
+#endif
+            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 || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_GRAAL
+    return PyObject_RichCompareBool(s1, s2, equals);
+#else
+    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 (s1_is_unicode & s2_is_unicode) {
+        Py_ssize_t length, length2;
+        int kind;
+        void *data1, *data2;
+        #if !CYTHON_COMPILING_IN_LIMITED_API
+        if (unlikely(__Pyx_PyUnicode_READY(s1) < 0) || unlikely(__Pyx_PyUnicode_READY(s2) < 0))
+            return -1;
+        #endif
+        length = __Pyx_PyUnicode_GET_LENGTH(s1);
+        #if !CYTHON_ASSUME_SAFE_SIZE
+        if (unlikely(length < 0)) return -1;
+        #endif
+        length2 = __Pyx_PyUnicode_GET_LENGTH(s2);
+        #if !CYTHON_ASSUME_SAFE_SIZE
+        if (unlikely(length2 < 0)) return -1;
+        #endif
+        if (length != length2) {
+            goto return_ne;
+        }
+#if CYTHON_USE_UNICODE_INTERNALS
+        {
+            Py_hash_t hash1, hash2;
+            hash1 = ((PyASCIIObject*)s1)->hash;
+            hash2 = ((PyASCIIObject*)s2)->hash;
+            if (hash1 != hash2 && hash1 != -1 && hash2 != -1) {
+                goto return_ne;
+            }
+        }
+#endif
+        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));
+            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:
+    return (equals == Py_EQ);
+return_ne:
+    return (equals == Py_NE);
+#endif
+}
+
+/* fastcall */
+#if CYTHON_METH_FASTCALL
+static CYTHON_INLINE PyObject * __Pyx_GetKwValue_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues, PyObject *s)
+{
+    Py_ssize_t i, n = __Pyx_PyTuple_GET_SIZE(kwnames);
+    #if !CYTHON_ASSUME_SAFE_SIZE
+    if (unlikely(n == -1)) return NULL;
+    #endif
+    for (i = 0; i < n; i++)
+    {
+        PyObject *namei = __Pyx_PyTuple_GET_ITEM(kwnames, i);
+        #if !CYTHON_ASSUME_SAFE_MACROS
+        if (unlikely(!namei)) return NULL;
+        #endif
+        if (s == namei) return kwvalues[i];
+    }
+    for (i = 0; i < n; i++)
+    {
+        PyObject *namei = __Pyx_PyTuple_GET_ITEM(kwnames, i);
+        #if !CYTHON_ASSUME_SAFE_MACROS
+        if (unlikely(!namei)) return NULL;
+        #endif
+        int eq = __Pyx_PyUnicode_Equals(s, namei, Py_EQ);
+        if (unlikely(eq != 0)) {
+            if (unlikely(eq < 0)) return NULL;
+            return kwvalues[i];
+        }
+    }
+    return NULL;
+}
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000 || CYTHON_COMPILING_IN_LIMITED_API
+CYTHON_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues) {
+    Py_ssize_t i, nkwargs;
+    PyObject *dict;
+#if !CYTHON_ASSUME_SAFE_SIZE
+    nkwargs = PyTuple_Size(kwnames);
+    if (unlikely(nkwargs < 0)) return NULL;
+#else
+    nkwargs = PyTuple_GET_SIZE(kwnames);
+#endif
+    dict = PyDict_New();
+    if (unlikely(!dict))
+        return NULL;
+    for (i=0; i<nkwargs; i++) {
+#if !CYTHON_ASSUME_SAFE_MACROS
+        PyObject *key = PyTuple_GetItem(kwnames, i);
+        if (!key) goto bad;
+#else
+        PyObject *key = PyTuple_GET_ITEM(kwnames, i);
+#endif
+        if (unlikely(PyDict_SetItem(dict, key, kwvalues[i]) < 0))
+            goto bad;
+    }
+    return dict;
+bad:
+    Py_DECREF(dict);
+    return NULL;
+}
+#endif
+#endif
+
+/* RaiseDoubleKeywords */
+static void __Pyx_RaiseDoubleKeywordsError(
+    const char* func_name,
+    PyObject* kw_name)
+{
+    PyErr_Format(PyExc_TypeError,
+        "%s() got multiple values for keyword argument '%U'", func_name, kw_name);
+}
+
+/* UnpackUnboundCMethod */
+#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030C0000
+static PyObject *__Pyx_SelflessCall(PyObject *method, PyObject *args, PyObject *kwargs) {
+    PyObject *result;
+    PyObject *selfless_args = PyTuple_GetSlice(args, 1, PyTuple_Size(args));
+    if (unlikely(!selfless_args)) return NULL;
+    result = PyObject_Call(method, selfless_args, kwargs);
+    Py_DECREF(selfless_args);
+    return result;
+}
+#elif CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x03090000
+static PyObject *__Pyx_SelflessCall(PyObject *method, PyObject **args, Py_ssize_t nargs, PyObject *kwnames) {
+        return _PyObject_Vectorcall
+            (method, args ? args+1 : NULL, nargs ? nargs-1 : 0, kwnames);
+}
+#else
+static PyObject *__Pyx_SelflessCall(PyObject *method, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames) {
+    return
+#if PY_VERSION_HEX < 0x03090000
+    _PyObject_Vectorcall
+#else
+    PyObject_Vectorcall
+#endif
+        (method, args ? args+1 : NULL, nargs ? (size_t) nargs-1 : 0, kwnames);
+}
+#endif
+static PyMethodDef __Pyx_UnboundCMethod_Def = {
+     "CythonUnboundCMethod",
+     __PYX_REINTERPRET_FUNCION(PyCFunction, __Pyx_SelflessCall),
+#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030C0000
+     METH_VARARGS | METH_KEYWORDS,
+#else
+     METH_FASTCALL | METH_KEYWORDS,
+#endif
+     NULL
+};
+static int __Pyx_TryUnpackUnboundCMethod(__Pyx_CachedCFunction* target) {
+    PyObject *method, *result=NULL;
+    method = __Pyx_PyObject_GetAttrStr(target->type, *target->method_name);
+    if (unlikely(!method))
+        return -1;
+    result = method;
+#if CYTHON_COMPILING_IN_CPYTHON
+    if (likely(__Pyx_TypeCheck(method, &PyMethodDescr_Type)))
+    {
+        PyMethodDescrObject *descr = (PyMethodDescrObject*) method;
+        target->func = descr->d_method->ml_meth;
+        target->flag = descr->d_method->ml_flags & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_STACKLESS);
+    } else
+#endif
+#if CYTHON_COMPILING_IN_PYPY
+#else
+    if (PyCFunction_Check(method))
+#endif
+    {
+        PyObject *self;
+        int self_found;
+#if CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_PYPY
+        self = PyObject_GetAttrString(method, "__self__");
+        if (!self) {
+            PyErr_Clear();
+        }
+#else
+        self = PyCFunction_GET_SELF(method);
+#endif
+        self_found = (self && self != Py_None);
+#if CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_PYPY
+        Py_XDECREF(self);
+#endif
+        if (self_found) {
+            PyObject *unbound_method = PyCFunction_New(&__Pyx_UnboundCMethod_Def, method);
+            if (unlikely(!unbound_method)) return -1;
+            Py_DECREF(method);
+            result = unbound_method;
+        }
+    }
+#if !CYTHON_COMPILING_IN_CPYTHON_FREETHREADING
+    if (unlikely(target->method)) {
+        Py_DECREF(result);
+    } else
 #endif
+    target->method = result;
+    return 0;
+}
 
-/* PyObjectCallMethO */
+/* CallUnboundCMethod2 */
 #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");
+static CYTHON_INLINE PyObject *__Pyx_CallUnboundCMethod2(__Pyx_CachedCFunction *cfunc, PyObject *self, PyObject *arg1, PyObject *arg2) {
+    int was_initialized = __Pyx_CachedCFunction_GetAndSetInitializing(cfunc);
+    if (likely(was_initialized == 2 && cfunc->func)) {
+        PyObject *args[2] = {arg1, arg2};
+        if (cfunc->flag == METH_FASTCALL) {
+            return __Pyx_CallCFunctionFast(cfunc, self, args, 2);
+        }
+        if (cfunc->flag == (METH_FASTCALL | METH_KEYWORDS))
+            return __Pyx_CallCFunctionFastWithKeywords(cfunc, self, args, 2, NULL);
+    }
+#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING
+    else if (unlikely(was_initialized == 1)) {
+        __Pyx_CachedCFunction tmp_cfunc = {
+#ifndef __cplusplus
+            0
+#endif
+        };
+        tmp_cfunc.type = cfunc->type;
+        tmp_cfunc.method_name = cfunc->method_name;
+        return __Pyx__CallUnboundCMethod2(&tmp_cfunc, self, arg1, arg2);
     }
+#endif
+    PyObject *result = __Pyx__CallUnboundCMethod2(cfunc, self, arg1, arg2);
+    __Pyx_CachedCFunction_SetFinishedInitializing(cfunc);
     return result;
 }
 #endif
-
-/* PyObjectCallOneArg */
+static PyObject* __Pyx__CallUnboundCMethod2(__Pyx_CachedCFunction* cfunc, PyObject* self, PyObject* arg1, PyObject* arg2){
+    if (unlikely(!cfunc->func && !cfunc->method) && unlikely(__Pyx_TryUnpackUnboundCMethod(cfunc) < 0)) return NULL;
 #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);
+    if (cfunc->func && (cfunc->flag & METH_VARARGS)) {
+        PyObject *result = NULL;
+        PyObject *args = PyTuple_New(2);
+        if (unlikely(!args)) return NULL;
+        Py_INCREF(arg1);
+        PyTuple_SET_ITEM(args, 0, arg1);
+        Py_INCREF(arg2);
+        PyTuple_SET_ITEM(args, 1, arg2);
+        if (cfunc->flag & METH_KEYWORDS)
+            result = __Pyx_CallCFunctionWithKeywords(cfunc, self, args, NULL);
+        else
+            result = __Pyx_CallCFunction(cfunc, self, args);
+        Py_DECREF(args);
+        return result;
     }
 #endif
-    if (likely(PyCFunction_Check(func))) {
-        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
-        }
+    {
+        PyObject *args[4] = {NULL, self, arg1, arg2};
+        return __Pyx_PyObject_FastCall(cfunc->method, args+1, 3 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET);
     }
-    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
 
-/* 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);
+/* ParseKeywords */
+static int __Pyx_ValidateDuplicatePosArgs(
+    PyObject *kwds,
+    PyObject ** const argnames[],
+    PyObject ** const *first_kw_arg,
+    const char* function_name)
+{
+    PyObject ** const *name = argnames;
+    while (name != first_kw_arg) {
+        PyObject *key = **name;
+        int found = PyDict_Contains(kwds, key);
+        if (unlikely(found)) {
+            if (found == 1) __Pyx_RaiseDoubleKeywordsError(function_name, key);
+            goto bad;
+        }
+        name++;
+    }
+    return 0;
+bad:
+    return -1;
 }
-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;
+#if CYTHON_USE_UNICODE_INTERNALS
+static CYTHON_INLINE int __Pyx_UnicodeKeywordsEqual(PyObject *s1, PyObject *s2) {
+    int kind;
+    Py_ssize_t len = PyUnicode_GET_LENGTH(s1);
+    if (len != PyUnicode_GET_LENGTH(s2)) return 0;
+    kind = PyUnicode_KIND(s1);
+    if (kind != PyUnicode_KIND(s2)) return 0;
+    const void *data1 = PyUnicode_DATA(s1);
+    const void *data2 = PyUnicode_DATA(s2);
+    return (memcmp(data1, data2, (size_t) len * (size_t) kind) == 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;
-        }
+static int __Pyx_MatchKeywordArg_str(
+    PyObject *key,
+    PyObject ** const argnames[],
+    PyObject ** const *first_kw_arg,
+    size_t *index_found,
+    const char *function_name)
+{
+    PyObject ** const *name;
+    #if CYTHON_USE_UNICODE_INTERNALS
+    Py_hash_t key_hash = ((PyASCIIObject*)key)->hash;
+    if (unlikely(key_hash == -1)) {
+        key_hash = PyObject_Hash(key);
+        if (unlikely(key_hash == -1))
+            goto bad;
     }
-    if (PyType_Check(type)) {
-#if CYTHON_COMPILING_IN_PYPY
-        if (!value) {
-            Py_INCREF(Py_None);
-            value = Py_None;
+    #endif
+    name = first_kw_arg;
+    while (*name) {
+        PyObject *name_str = **name;
+        #if CYTHON_USE_UNICODE_INTERNALS
+        if (key_hash == ((PyASCIIObject*)name_str)->hash && __Pyx_UnicodeKeywordsEqual(name_str, key)) {
+            *index_found = (size_t) (name - argnames);
+            return 1;
         }
-#endif
-        PyErr_NormalizeException(&type, &value, &tb);
-    } else {
-        if (value) {
-            PyErr_SetString(PyExc_TypeError,
-                "instance exception may not have a separate value");
-            goto raise_error;
+        #else
+        #if CYTHON_ASSUME_SAFE_SIZE
+        if (PyUnicode_GET_LENGTH(name_str) == PyUnicode_GET_LENGTH(key))
+        #endif
+        {
+            int cmp = PyUnicode_Compare(name_str, key);
+            if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad;
+            if (cmp == 0) {
+                *index_found = (size_t) (name - argnames);
+                return 1;
+            }
         }
-        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;
+        #endif
+        name++;
+    }
+    name = argnames;
+    while (name != first_kw_arg) {
+        PyObject *name_str = **name;
+        #if CYTHON_USE_UNICODE_INTERNALS
+        if (unlikely(key_hash == ((PyASCIIObject*)name_str)->hash)) {
+            if (__Pyx_UnicodeKeywordsEqual(name_str, key))
+                goto arg_passed_twice;
+        }
+        #else
+        #if CYTHON_ASSUME_SAFE_SIZE
+        if (PyUnicode_GET_LENGTH(name_str) == PyUnicode_GET_LENGTH(key))
+        #endif
+        {
+            if (unlikely(name_str == key)) goto arg_passed_twice;
+            int cmp = PyUnicode_Compare(name_str, key);
+            if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad;
+            if (cmp == 0) goto arg_passed_twice;
         }
+        #endif
+        name++;
     }
-    __Pyx_PyThreadState_assign
-    __Pyx_ErrRestore(type, value, tb);
-    return;
-raise_error:
-    Py_XDECREF(value);
-    Py_XDECREF(type);
-    Py_XDECREF(tb);
-    return;
+    return 0;
+arg_passed_twice:
+    __Pyx_RaiseDoubleKeywordsError(function_name, key);
+    goto bad;
+bad:
+    return -1;
 }
-#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;
+static int __Pyx_MatchKeywordArg_nostr(
+    PyObject *key,
+    PyObject ** const argnames[],
+    PyObject ** const *first_kw_arg,
+    size_t *index_found,
+    const char *function_name)
+{
+    PyObject ** const *name;
+    if (unlikely(!PyUnicode_Check(key))) goto invalid_keyword_type;
+    name = first_kw_arg;
+    while (*name) {
+        int cmp = PyObject_RichCompareBool(**name, key, Py_EQ);
+        if (cmp == 1) {
+            *index_found = (size_t) (name - argnames);
+            return 1;
+        }
+        if (unlikely(cmp == -1)) goto bad;
+        name++;
     }
-    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;
+    name = argnames;
+    while (name != first_kw_arg) {
+        int cmp = PyObject_RichCompareBool(**name, key, Py_EQ);
+        if (unlikely(cmp != 0)) {
+            if (cmp == 1) goto arg_passed_twice;
+            else 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;
+        name++;
+    }
+    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;
+bad:
+    return -1;
+}
+static CYTHON_INLINE int __Pyx_MatchKeywordArg(
+    PyObject *key,
+    PyObject ** const argnames[],
+    PyObject ** const *first_kw_arg,
+    size_t *index_found,
+    const char *function_name)
+{
+    return likely(PyUnicode_CheckExact(key)) ?
+        __Pyx_MatchKeywordArg_str(key, argnames, first_kw_arg, index_found, function_name) :
+        __Pyx_MatchKeywordArg_nostr(key, argnames, first_kw_arg, index_found, function_name);
+}
+static void __Pyx_RejectUnknownKeyword(
+    PyObject *kwds,
+    PyObject ** const argnames[],
+    PyObject ** const *first_kw_arg,
+    const char *function_name)
+{
+    Py_ssize_t pos = 0;
+    PyObject *key = NULL;
+    __Pyx_BEGIN_CRITICAL_SECTION(kwds);
+    while (PyDict_Next(kwds, &pos, &key, NULL)) {
+        PyObject** const *name = first_kw_arg;
+        while (*name && (**name != key)) name++;
+        if (!*name) {
+            #if CYTHON_AVOID_BORROWED_REFS
+            Py_INCREF(key);
+            #endif
+            size_t index_found = 0;
+            int cmp = __Pyx_MatchKeywordArg(key, argnames, first_kw_arg, &index_found, function_name);
+            if (cmp != 1) {
+                if (cmp == 0) {
+                    PyErr_Format(PyExc_TypeError,
+                        "%s() got an unexpected keyword argument '%U'",
+                        function_name, key);
                 }
+                #if CYTHON_AVOID_BORROWED_REFS
+                Py_DECREF(key);
+                #endif
+                break;
             }
+            #if CYTHON_AVOID_BORROWED_REFS
+            Py_DECREF(key);
+            #endif
         }
-        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;
-            }
+    }
+    __Pyx_END_CRITICAL_SECTION();
+    assert(PyErr_Occurred());
+}
+static int __Pyx_ParseKeywordDict(
+    PyObject *kwds,
+    PyObject ** const argnames[],
+    PyObject *values[],
+    Py_ssize_t num_pos_args,
+    Py_ssize_t num_kwargs,
+    const char* function_name,
+    int ignore_unknown_kwargs)
+{
+    PyObject** const *name;
+    PyObject** const *first_kw_arg = argnames + num_pos_args;
+    Py_ssize_t extracted = 0;
+#if !CYTHON_COMPILING_IN_PYPY || defined(PyArg_ValidateKeywordArguments)
+    if (unlikely(!PyArg_ValidateKeywordArguments(kwds))) return -1;
+#endif
+    name = first_kw_arg;
+    while (*name && num_kwargs > extracted) {
+        PyObject * key = **name;
+        PyObject *value;
+        int found = 0;
+        #if __PYX_LIMITED_VERSION_HEX >= 0x030d0000
+        found = PyDict_GetItemRef(kwds, key, &value);
+        #else
+        value = PyDict_GetItemWithError(kwds, key);
+        if (value) {
+            Py_INCREF(value);
+            found = 1;
+        } else {
+            if (unlikely(PyErr_Occurred())) goto bad;
         }
-    } else {
-        PyErr_SetString(PyExc_TypeError,
-            "raise: exception class must be a subclass of BaseException");
-        goto bad;
+        #endif
+        if (found) {
+            if (unlikely(found < 0)) goto bad;
+            values[name-argnames] = value;
+            extracted++;
+        }
+        name++;
     }
-    if (cause) {
-        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)
+    if (num_kwargs > extracted) {
+        if (ignore_unknown_kwargs) {
+            if (unlikely(__Pyx_ValidateDuplicatePosArgs(kwds, argnames, first_kw_arg, function_name) == -1))
                 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");
+            __Pyx_RejectUnknownKeyword(kwds, argnames, first_kw_arg, function_name);
             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);
+    return 0;
+bad:
+    return -1;
+}
+static int __Pyx_ParseKeywordDictToDict(
+    PyObject *kwds,
+    PyObject ** const argnames[],
+    PyObject *kwds2,
+    PyObject *values[],
+    Py_ssize_t num_pos_args,
+    const char* function_name)
+{
+    PyObject** const *name;
+    PyObject** const *first_kw_arg = argnames + num_pos_args;
+    Py_ssize_t len;
+#if !CYTHON_COMPILING_IN_PYPY || defined(PyArg_ValidateKeywordArguments)
+    if (unlikely(!PyArg_ValidateKeywordArguments(kwds))) return -1;
+#endif
+    if (PyDict_Update(kwds2, kwds) < 0) goto bad;
+    name = first_kw_arg;
+    while (*name) {
+        PyObject *key = **name;
+        PyObject *value;
+#if !CYTHON_COMPILING_IN_LIMITED_API && (PY_VERSION_HEX >= 0x030d00A2 || defined(PyDict_Pop))
+        int found = PyDict_Pop(kwds2, key, &value);
+        if (found) {
+            if (unlikely(found < 0)) goto bad;
+            values[name-argnames] = value;
+        }
+#elif __PYX_LIMITED_VERSION_HEX >= 0x030d0000
+        int found = PyDict_GetItemRef(kwds2, key, &value);
+        if (found) {
+            if (unlikely(found < 0)) goto bad;
+            values[name-argnames] = value;
+            if (unlikely(PyDict_DelItem(kwds2, key) < 0)) goto bad;
+        }
 #else
-        PyThreadState *tstate = __Pyx_PyThreadState_Current;
-        PyObject* tmp_tb = tstate->curexc_traceback;
-        if (tb != tmp_tb) {
-            Py_INCREF(tb);
-            tstate->curexc_traceback = tb;
-            Py_XDECREF(tmp_tb);
+    #if CYTHON_COMPILING_IN_CPYTHON
+        value = _PyDict_Pop(kwds2, key, kwds2);
+    #else
+        value = __Pyx_CallUnboundCMethod2(&__pyx_mstate_global->__pyx_umethod_PyDict_Type_pop, kwds2, key, kwds2);
+    #endif
+        if (value == kwds2) {
+            Py_DECREF(value);
+        } else {
+            if (unlikely(!value)) goto bad;
+            values[name-argnames] = value;
         }
 #endif
+        name++;
+    }
+    len = PyDict_Size(kwds2);
+    if (len > 0) {
+        return __Pyx_ValidateDuplicatePosArgs(kwds, argnames, first_kw_arg, function_name);
+    } else if (unlikely(len == -1)) {
+        goto bad;
     }
+    return 0;
 bad:
-    Py_XDECREF(owned_instance);
-    return;
+    return -1;
 }
+static int __Pyx_ParseKeywordsTuple(
+    PyObject *kwds,
+    PyObject * const *kwvalues,
+    PyObject ** const argnames[],
+    PyObject *kwds2,
+    PyObject *values[],
+    Py_ssize_t num_pos_args,
+    Py_ssize_t num_kwargs,
+    const char* function_name,
+    int ignore_unknown_kwargs)
+{
+    PyObject *key = NULL;
+    PyObject** const * name;
+    PyObject** const *first_kw_arg = argnames + num_pos_args;
+    for (Py_ssize_t pos = 0; pos < num_kwargs; pos++) {
+#if CYTHON_AVOID_BORROWED_REFS
+        key = __Pyx_PySequence_ITEM(kwds, pos);
+#else
+        key = __Pyx_PyTuple_GET_ITEM(kwds, pos);
+#endif
+#if !CYTHON_ASSUME_SAFE_MACROS
+        if (unlikely(!key)) goto bad;
 #endif
+        name = first_kw_arg;
+        while (*name && (**name != key)) name++;
+        if (*name) {
+            PyObject *value = kwvalues[pos];
+            values[name-argnames] = __Pyx_NewRef(value);
+        } else {
+            size_t index_found = 0;
+            int cmp = __Pyx_MatchKeywordArg(key, argnames, first_kw_arg, &index_found, function_name);
+            if (cmp == 1) {
+                PyObject *value = kwvalues[pos];
+                values[index_found] = __Pyx_NewRef(value);
+            } else {
+                if (unlikely(cmp == -1)) goto bad;
+                if (kwds2) {
+                    PyObject *value = kwvalues[pos];
+                    if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad;
+                } else if (!ignore_unknown_kwargs) {
+                    goto invalid_keyword;
+                }
+            }
+        }
+        #if CYTHON_AVOID_BORROWED_REFS
+        Py_DECREF(key);
+        key = NULL;
+        #endif
+    }
+    return 0;
+invalid_keyword:
+    PyErr_Format(PyExc_TypeError,
+        "%s() got an unexpected keyword argument '%U'",
+        function_name, key);
+    goto bad;
+bad:
+    #if CYTHON_AVOID_BORROWED_REFS
+    Py_XDECREF(key);
+    #endif
+    return -1;
+}
+static int __Pyx_ParseKeywords(
+    PyObject *kwds,
+    PyObject * const *kwvalues,
+    PyObject ** const argnames[],
+    PyObject *kwds2,
+    PyObject *values[],
+    Py_ssize_t num_pos_args,
+    Py_ssize_t num_kwargs,
+    const char* function_name,
+    int ignore_unknown_kwargs)
+{
+    if (CYTHON_METH_FASTCALL && likely(PyTuple_Check(kwds)))
+        return __Pyx_ParseKeywordsTuple(kwds, kwvalues, argnames, kwds2, values, num_pos_args, num_kwargs, function_name, ignore_unknown_kwargs);
+    else if (kwds2)
+        return __Pyx_ParseKeywordDictToDict(kwds, argnames, kwds2, values, num_pos_args, function_name);
+    else
+        return __Pyx_ParseKeywordDict(kwds, argnames, values, num_pos_args, num_kwargs, function_name, ignore_unknown_kwargs);
+}
 
 /* RaiseArgTupleInvalid */
 static void __Pyx_RaiseArgtupleInvalid(
@@ -70501,143 +91509,80 @@ static void __Pyx_RaiseArgtupleInvalid(
                  (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 int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact)
 {
+    __Pyx_TypeName type_name;
+    __Pyx_TypeName obj_type_name;
+    PyObject *extra_info = __pyx_mstate_global->__pyx_empty_unicode;
+    int from_annotation_subclass = 0;
     if (unlikely(!type)) {
         PyErr_SetString(PyExc_SystemError, "Missing type object");
         return 0;
     }
-    else if (exact) {
-        #if PY_MAJOR_VERSION == 2
-        if ((type == &PyBaseString_Type) && likely(__Pyx_PyBaseString_CheckExact(obj))) return 1;
-        #endif
-    }
-    else {
+    else if (!exact) {
         if (likely(__Pyx_TypeCheck(obj, type))) return 1;
+    } else if (exact == 2) {
+        if (__Pyx_TypeCheck(obj, type)) {
+            from_annotation_subclass = 1;
+            extra_info = __pyx_mstate_global->__pyx_kp_u_Note_that_Cython_is_deliberately;
+        }
     }
+    type_name = __Pyx_PyType_GetFullyQualifiedName(type);
+    obj_type_name = __Pyx_PyType_GetFullyQualifiedName(Py_TYPE(obj));
     PyErr_Format(PyExc_TypeError,
-        "Argument '%.200s' has incorrect type (expected %.200s, got %.200s)",
-        name, type->tp_name, Py_TYPE(obj)->tp_name);
+        "Argument '%.200s' has incorrect type (expected " __Pyx_FMT_TYPENAME
+        ", got " __Pyx_FMT_TYPENAME ")"
+#if __PYX_LIMITED_VERSION_HEX < 0x030C0000
+        "%s%U"
+#endif
+        , name, type_name, obj_type_name
+#if __PYX_LIMITED_VERSION_HEX < 0x030C0000
+        , (from_annotation_subclass ? ". " : ""), extra_info
+#endif
+        );
+#if __PYX_LIMITED_VERSION_HEX >= 0x030C0000
+    if (exact == 2 && from_annotation_subclass) {
+        PyObject *res;
+        PyObject *vargs[2];
+        vargs[0] = PyErr_GetRaisedException();
+        vargs[1] = extra_info;
+        res = PyObject_VectorcallMethod(__pyx_mstate_global->__pyx_kp_u_add_note, vargs, 2, NULL);
+        Py_XDECREF(res);
+        PyErr_SetRaisedException(vargs[0]);
+    }
+#endif
+    __Pyx_DECREF_TypeName(type_name);
+    __Pyx_DECREF_TypeName(obj_type_name);
     return 0;
 }
 
+/* PyDictVersioning */
+#if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS
+static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj) {
+    PyObject *dict = Py_TYPE(obj)->tp_dict;
+    return likely(dict) ? __PYX_GET_DICT_VERSION(dict) : 0;
+}
+static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj) {
+    PyObject **dictptr = NULL;
+    Py_ssize_t offset = Py_TYPE(obj)->tp_dictoffset;
+    if (offset) {
+#if CYTHON_COMPILING_IN_CPYTHON
+        dictptr = (likely(offset > 0)) ? (PyObject **) ((char *)obj + offset) : _PyObject_GetDictPtr(obj);
+#else
+        dictptr = _PyObject_GetDictPtr(obj);
+#endif
+    }
+    return (dictptr && *dictptr) ? __PYX_GET_DICT_VERSION(*dictptr) : 0;
+}
+static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version) {
+    PyObject *dict = Py_TYPE(obj)->tp_dict;
+    if (unlikely(!dict) || unlikely(tp_dict_version != __PYX_GET_DICT_VERSION(dict)))
+        return 0;
+    return obj_dict_version == __Pyx_get_object_dict_version(obj);
+}
+#endif
+
 /* GetModuleGlobalName */
 #if CYTHON_USE_DICT_VERSIONS
 static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value)
@@ -70646,25 +91591,26 @@ static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name)
 #endif
 {
     PyObject *result;
-#if !CYTHON_AVOID_BORROWED_REFS
-#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1
-    result = _PyDict_GetItem_KnownHash(__pyx_d, name, ((PyASCIIObject *) name)->hash);
-    __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version)
-    if (likely(result)) {
-        return __Pyx_NewRef(result);
-    } else if (unlikely(PyErr_Occurred())) {
+#if CYTHON_COMPILING_IN_LIMITED_API
+    if (unlikely(!__pyx_m)) {
+        if (!PyErr_Occurred())
+            PyErr_SetNone(PyExc_NameError);
         return NULL;
     }
-#else
-    result = PyDict_GetItem(__pyx_d, name);
-    __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version)
+    result = PyObject_GetAttr(__pyx_m, name);
     if (likely(result)) {
-        return __Pyx_NewRef(result);
+        return result;
+    }
+    PyErr_Clear();
+#elif CYTHON_AVOID_BORROWED_REFS || CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS
+    if (unlikely(__Pyx_PyDict_GetItemRef(__pyx_mstate_global->__pyx_d, name, &result) == -1)) PyErr_Clear();
+    __PYX_UPDATE_DICT_CACHE(__pyx_mstate_global->__pyx_d, result, *dict_cached_value, *dict_version)
+    if (likely(result)) {
+        return result;
     }
-#endif
 #else
-    result = PyObject_GetItem(__pyx_d, name);
-    __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version)
+    result = _PyDict_GetItem_KnownHash(__pyx_mstate_global->__pyx_d, name, ((PyASCIIObject *) name)->hash);
+    __PYX_UPDATE_DICT_CACHE(__pyx_mstate_global->__pyx_d, result, *dict_cached_value, *dict_version)
     if (likely(result)) {
         return __Pyx_NewRef(result);
     }
@@ -70679,10 +91625,6 @@ static CYTHON_INLINE int __Pyx_PyObject_SetAttrStr(PyObject* obj, PyObject* attr
     PyTypeObject* tp = Py_TYPE(obj);
     if (likely(tp->tp_setattro))
         return tp->tp_setattro(obj, attr_name, value);
-#if PY_MAJOR_VERSION < 3
-    if (likely(tp->tp_setattr))
-        return tp->tp_setattr(obj, PyString_AS_STRING(attr_name), value);
-#endif
     return PyObject_SetAttr(obj, attr_name, value);
 }
 #endif
@@ -70690,7 +91632,7 @@ static CYTHON_INLINE int __Pyx_PyObject_SetAttrStr(PyObject* obj, PyObject* attr
 /* GetItemInt */
 static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j) {
     PyObject *r;
-    if (!j) return NULL;
+    if (unlikely(!j)) return NULL;
     r = PyObject_GetItem(o, j);
     Py_DECREF(j);
     return r;
@@ -70698,7 +91640,7 @@ static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j) {
 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 CYTHON_ASSUME_SAFE_MACROS && CYTHON_ASSUME_SAFE_SIZE && !CYTHON_AVOID_BORROWED_REFS && !CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS
     Py_ssize_t wrapped_i = i;
     if (wraparound & unlikely(i < 0)) {
         wrapped_i += PyList_GET_SIZE(o);
@@ -70708,7 +91650,7 @@ static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_
         Py_INCREF(r);
         return r;
     }
-    return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i));
+    return __Pyx_GetItemInt_Generic(o, PyLong_FromSsize_t(i));
 #else
     return PySequence_GetItem(o, i);
 #endif
@@ -70716,7 +91658,7 @@ static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_
 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 CYTHON_ASSUME_SAFE_MACROS && CYTHON_ASSUME_SAFE_SIZE && !CYTHON_AVOID_BORROWED_REFS
     Py_ssize_t wrapped_i = i;
     if (wraparound & unlikely(i < 0)) {
         wrapped_i += PyTuple_GET_SIZE(o);
@@ -70726,7 +91668,7 @@ static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize
         Py_INCREF(r);
         return r;
     }
-    return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i));
+    return __Pyx_GetItemInt_Generic(o, PyLong_FromSsize_t(i));
 #else
     return PySequence_GetItem(o, i);
 #endif
@@ -70734,13 +91676,11 @@ static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize
 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 CYTHON_ASSUME_SAFE_MACROS && CYTHON_ASSUME_SAFE_SIZE && !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(__Pyx_is_valid_index(n, PyList_GET_SIZE(o))))) {
-            PyObject *r = PyList_GET_ITEM(o, n);
-            Py_INCREF(r);
-            return r;
+            return __Pyx_PyList_GetItemRef(o, n);
         }
     }
     else if (PyTuple_CheckExact(o)) {
@@ -70751,10 +91691,18 @@ static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i,
             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);
+        PyMappingMethods *mm = Py_TYPE(o)->tp_as_mapping;
+        PySequenceMethods *sm = Py_TYPE(o)->tp_as_sequence;
+        if (mm && mm->mp_subscript) {
+            PyObject *r, *key = PyLong_FromSsize_t(i);
+            if (unlikely(!key)) return NULL;
+            r = mm->mp_subscript(o, key);
+            Py_DECREF(key);
+            return r;
+        }
+        if (likely(sm && sm->sq_item)) {
+            if (wraparound && unlikely(i < 0) && likely(sm->sq_length)) {
+                Py_ssize_t l = sm->sq_length(o);
                 if (likely(l >= 0)) {
                     i += l;
                 } else {
@@ -70763,117 +91711,120 @@ static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i,
                     PyErr_Clear();
                 }
             }
-            return m->sq_item(o, i);
+            return sm->sq_item(o, i);
         }
     }
 #else
-    if (is_list || PySequence_Check(o)) {
+    if (is_list || !PyMapping_Check(o)) {
         return PySequence_GetItem(o, i);
     }
 #endif
-    return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i));
+    return __Pyx_GetItemInt_Generic(o, PyLong_FromSsize_t(i));
+}
+
+/* PyObjectCallOneArg */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) {
+    PyObject *args[2] = {NULL, arg};
+    return __Pyx_PyObject_FastCall(func, args+1, 1 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET);
 }
 
 /* ObjectGetItem */
 #if CYTHON_USE_TYPE_SLOTS
-static PyObject *__Pyx_PyObject_GetIndex(PyObject *obj, PyObject* index) {
-    PyObject *runerr;
+static PyObject *__Pyx_PyObject_GetIndex(PyObject *obj, PyObject *index) {
+    PyObject *runerr = NULL;
     Py_ssize_t key_value;
-    PySequenceMethods *m = Py_TYPE(obj)->tp_as_sequence;
-    if (unlikely(!(m && m->sq_item))) {
-        PyErr_Format(PyExc_TypeError, "'%.200s' object is not subscriptable", Py_TYPE(obj)->tp_name);
-        return NULL;
-    }
     key_value = __Pyx_PyIndex_AsSsize_t(index);
     if (likely(key_value != -1 || !(runerr = PyErr_Occurred()))) {
         return __Pyx_GetItemInt_Fast(obj, key_value, 0, 1, 1);
     }
     if (PyErr_GivenExceptionMatches(runerr, PyExc_OverflowError)) {
+        __Pyx_TypeName index_type_name = __Pyx_PyType_GetFullyQualifiedName(Py_TYPE(index));
         PyErr_Clear();
-        PyErr_Format(PyExc_IndexError, "cannot fit '%.200s' into an index-sized integer", Py_TYPE(index)->tp_name);
+        PyErr_Format(PyExc_IndexError,
+            "cannot fit '" __Pyx_FMT_TYPENAME "' into an index-sized integer", index_type_name);
+        __Pyx_DECREF_TypeName(index_type_name);
     }
     return NULL;
 }
-static PyObject *__Pyx_PyObject_GetItem(PyObject *obj, PyObject* key) {
-    PyMappingMethods *m = Py_TYPE(obj)->tp_as_mapping;
-    if (likely(m && m->mp_subscript)) {
-        return m->mp_subscript(obj, key);
+static PyObject *__Pyx_PyObject_GetItem_Slow(PyObject *obj, PyObject *key) {
+    __Pyx_TypeName obj_type_name;
+    if (likely(PyType_Check(obj))) {
+        PyObject *meth = __Pyx_PyObject_GetAttrStrNoError(obj, __pyx_mstate_global->__pyx_n_u_class_getitem);
+        if (!meth) {
+            PyErr_Clear();
+        } else {
+            PyObject *result = __Pyx_PyObject_CallOneArg(meth, key);
+            Py_DECREF(meth);
+            return result;
+        }
     }
-    return __Pyx_PyObject_GetIndex(obj, key);
+    obj_type_name = __Pyx_PyType_GetFullyQualifiedName(Py_TYPE(obj));
+    PyErr_Format(PyExc_TypeError,
+        "'" __Pyx_FMT_TYPENAME "' object is not subscriptable", obj_type_name);
+    __Pyx_DECREF_TypeName(obj_type_name);
+    return NULL;
 }
-#endif
-
-/* PyObjectCall2Args */
-static CYTHON_UNUSED PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2) {
-    PyObject *args, *result = NULL;
-    #if CYTHON_FAST_PYCALL
-    if (PyFunction_Check(function)) {
-        PyObject *args[2] = {arg1, arg2};
-        return __Pyx_PyFunction_FastCall(function, args, 2);
+static PyObject *__Pyx_PyObject_GetItem(PyObject *obj, PyObject *key) {
+    PyTypeObject *tp = Py_TYPE(obj);
+    PyMappingMethods *mm = tp->tp_as_mapping;
+    PySequenceMethods *sm = tp->tp_as_sequence;
+    if (likely(mm && mm->mp_subscript)) {
+        return mm->mp_subscript(obj, key);
     }
-    #endif
-    #if CYTHON_FAST_PYCCALL
-    if (__Pyx_PyFastCFunction_Check(function)) {
-        PyObject *args[2] = {arg1, arg2};
-        return __Pyx_PyCFunction_FastCall(function, args, 2);
+    if (likely(sm && sm->sq_item)) {
+        return __Pyx_PyObject_GetIndex(obj, key);
     }
-    #endif
-    args = PyTuple_New(2);
-    if (unlikely(!args)) goto done;
-    Py_INCREF(arg1);
-    PyTuple_SET_ITEM(args, 0, arg1);
-    Py_INCREF(arg2);
-    PyTuple_SET_ITEM(args, 1, arg2);
-    Py_INCREF(function);
-    result = __Pyx_PyObject_Call(function, args, NULL);
-    Py_DECREF(args);
-    Py_DECREF(function);
-done:
+    return __Pyx_PyObject_GetItem_Slow(obj, key);
+}
+#endif
+
+/* PyObjectFastCallMethod */
+#if !CYTHON_VECTORCALL || PY_VERSION_HEX < 0x03090000
+static PyObject *__Pyx_PyObject_FastCallMethod(PyObject *name, PyObject *const *args, size_t nargsf) {
+    PyObject *result;
+    PyObject *attr = PyObject_GetAttr(args[0], name);
+    if (unlikely(!attr))
+        return NULL;
+    result = __Pyx_PyObject_FastCall(attr, args+1, nargsf - 1);
+    Py_DECREF(attr);
     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);
+/* HasAttr */
+#if __PYX_LIMITED_VERSION_HEX < 0x030d0000
+static CYTHON_INLINE int __Pyx_HasAttr(PyObject *o, PyObject *n) {
+    PyObject *r;
+    if (unlikely(!PyUnicode_Check(n))) {
+        PyErr_SetString(PyExc_TypeError,
+                        "hasattr(): attribute name must be string");
+        return -1;
     }
-#endif
-#ifdef __Pyx_CyFunction_USED
-    if (likely(PyCFunction_Check(func) || __Pyx_CyFunction_Check(func)))
-#else
-    if (likely(PyCFunction_Check(func)))
-#endif
-    {
-        if (likely(PyCFunction_GET_FLAGS(func) & METH_NOARGS)) {
-            return __Pyx_PyObject_CallMethO(func, NULL);
-        }
+    r = __Pyx_PyObject_GetAttrStrNoError(o, n);
+    if (!r) {
+        return (unlikely(PyErr_Occurred())) ? -1 : 0;
+    } else {
+        Py_DECREF(r);
+        return 1;
     }
-    return __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL);
 }
 #endif
 
 /* DictGetItem */
-#if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY
+#if !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()) {
-            if (unlikely(PyTuple_Check(key))) {
-                PyObject* args = PyTuple_Pack(1, key);
-                if (likely(args)) {
-                    PyErr_SetObject(PyExc_KeyError, args);
-                    Py_DECREF(args);
-                }
-            } else {
-                PyErr_SetObject(PyExc_KeyError, key);
+    if (unlikely(__Pyx_PyDict_GetItemRef(d, key, &value) == 0)) { // no value, no error
+        if (unlikely(PyTuple_Check(key))) {
+            PyObject* args = PyTuple_Pack(1, key);
+            if (likely(args)) {
+                PyErr_SetObject(PyExc_KeyError, args);
+                Py_DECREF(args);
             }
+        } else {
+            PyErr_SetObject(PyExc_KeyError, key);
         }
-        return NULL;
     }
-    Py_INCREF(value);
     return value;
 }
 #endif
@@ -70893,37 +91844,17 @@ static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index) {
 
 /* IterFinish */
 static CYTHON_INLINE int __Pyx_IterFinish(void) {
-#if CYTHON_FAST_THREAD_STATE
-    PyThreadState *tstate = __Pyx_PyThreadState_Current;
-    PyObject* exc_type = tstate->curexc_type;
+    PyObject* exc_type;
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    exc_type = __Pyx_PyErr_CurrentExceptionType();
     if (unlikely(exc_type)) {
-        if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) {
-            PyObject *exc_value, *exc_tb;
-            exc_value = tstate->curexc_value;
-            exc_tb = tstate->curexc_traceback;
-            tstate->curexc_type = 0;
-            tstate->curexc_value = 0;
-            tstate->curexc_traceback = 0;
-            Py_DECREF(exc_type);
-            Py_XDECREF(exc_value);
-            Py_XDECREF(exc_tb);
-            return 0;
-        } else {
-            return -1;
-        }
-    }
-    return 0;
-#else
-    if (unlikely(PyErr_Occurred())) {
-        if (likely(PyErr_ExceptionMatches(PyExc_StopIteration))) {
-            PyErr_Clear();
-            return 0;
-        } else {
+        if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration)))
             return -1;
-        }
+        __Pyx_PyErr_Clear();
+        return 0;
     }
     return 0;
-#endif
 }
 
 /* UnpackItemEndCheck */
@@ -70932,23 +91863,21 @@ static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected) {
         Py_DECREF(retval);
         __Pyx_RaiseTooManyValuesError(expected);
         return -1;
-    } else {
-        return __Pyx_IterFinish();
     }
-    return 0;
+    return __Pyx_IterFinish();
 }
 
-/* StringJoin */
-#if !CYTHON_COMPILING_IN_CPYTHON
-static CYTHON_INLINE PyObject* __Pyx_PyBytes_Join(PyObject* sep, PyObject* values) {
-    return PyObject_CallMethodObjArgs(sep, __pyx_n_s_join, values, NULL);
+/* PyObjectCallNoArg */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func) {
+    PyObject *arg[2] = {NULL, NULL};
+    return __Pyx_PyObject_FastCall(func, arg + 1, 0 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET);
 }
-#endif
 
 /* PyObjectGetMethod */
 static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method) {
     PyObject *attr;
 #if CYTHON_UNPACK_METHODS && CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_PYTYPE_LOOKUP
+    __Pyx_TypeName type_name;
     PyTypeObject *tp = Py_TYPE(obj);
     PyObject *descr;
     descrgetfunc f = NULL;
@@ -70965,17 +91894,13 @@ static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **me
     descr = _PyType_Lookup(tp, name);
     if (likely(descr != NULL)) {
         Py_INCREF(descr);
-#if PY_MAJOR_VERSION >= 3
-        #ifdef __Pyx_CyFunction_USED
-        if (likely(PyFunction_Check(descr) || (Py_TYPE(descr) == &PyMethodDescr_Type) || __Pyx_CyFunction_Check(descr)))
-        #else
-        if (likely(PyFunction_Check(descr) || (Py_TYPE(descr) == &PyMethodDescr_Type)))
-        #endif
+#if defined(Py_TPFLAGS_METHOD_DESCRIPTOR) && Py_TPFLAGS_METHOD_DESCRIPTOR
+        if (__Pyx_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR))
 #else
         #ifdef __Pyx_CyFunction_USED
-        if (likely(PyFunction_Check(descr) || __Pyx_CyFunction_Check(descr)))
+        if (likely(PyFunction_Check(descr) || __Pyx_IS_TYPE(descr, &PyMethodDescr_Type) || __Pyx_CyFunction_Check(descr)))
         #else
-        if (likely(PyFunction_Check(descr)))
+        if (likely(PyFunction_Check(descr) || __Pyx_IS_TYPE(descr, &PyMethodDescr_Type)))
         #endif
 #endif
         {
@@ -71010,18 +91935,15 @@ static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **me
         Py_DECREF(descr);
         goto try_unpack;
     }
-    if (descr != NULL) {
+    if (likely(descr != NULL)) {
         *method = descr;
         return 0;
     }
+    type_name = __Pyx_PyType_GetFullyQualifiedName(tp);
     PyErr_Format(PyExc_AttributeError,
-#if PY_MAJOR_VERSION >= 3
-                 "'%.50s' object has no attribute '%U'",
-                 tp->tp_name, name);
-#else
-                 "'%.50s' object has no attribute '%.400s'",
-                 tp->tp_name, PyString_AS_STRING(name));
-#endif
+                 "'" __Pyx_FMT_TYPENAME "' object has no attribute '%U'",
+                 type_name, name);
+    __Pyx_DECREF_TypeName(type_name);
     return 0;
 #else
     attr = __Pyx_PyObject_GetAttrStr(obj, name);
@@ -71043,6 +91965,13 @@ static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **me
 
 /* PyObjectCallMethod0 */
 static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name) {
+#if CYTHON_VECTORCALL && (__PYX_LIMITED_VERSION_HEX >= 0x030C0000 || (!CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x03090000))
+    PyObject *args[1] = {obj};
+    (void) __Pyx_PyObject_GetMethod;
+    (void) __Pyx_PyObject_CallOneArg;
+    (void) __Pyx_PyObject_CallNoArg;
+    return PyObject_VectorcallMethod(method_name, args, 1 | PY_VECTORCALL_ARGUMENTS_OFFSET, NULL);
+#else
     PyObject *method = NULL, *result = NULL;
     int is_method = __Pyx_PyObject_GetMethod(obj, method_name, &method);
     if (likely(is_method)) {
@@ -71055,6 +91984,7 @@ static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name
     Py_DECREF(method);
 bad:
     return result;
+#endif
 }
 
 /* RaiseNoneIterError */
@@ -71066,20 +91996,45 @@ static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void) {
 static void __Pyx_UnpackTupleError(PyObject *t, Py_ssize_t index) {
     if (t == Py_None) {
       __Pyx_RaiseNoneNotIterableError();
-    } else if (PyTuple_GET_SIZE(t) < index) {
-      __Pyx_RaiseNeedMoreValuesError(PyTuple_GET_SIZE(t));
     } else {
-      __Pyx_RaiseTooManyValuesError(index);
+      Py_ssize_t size = __Pyx_PyTuple_GET_SIZE(t);
+ #if !CYTHON_ASSUME_SAFE_SIZE
+      if (unlikely(size < 0)) return;
+ #endif
+      if (size < index) {
+        __Pyx_RaiseNeedMoreValuesError(size);
+      } else {
+        __Pyx_RaiseTooManyValuesError(index);
+      }
     }
 }
 
 /* UnpackTuple2 */
+static CYTHON_INLINE int __Pyx_unpack_tuple2(
+        PyObject* tuple, PyObject** value1, PyObject** value2, int is_tuple, int has_known_size, int decref_tuple) {
+    if (likely(is_tuple || PyTuple_Check(tuple))) {
+        Py_ssize_t size;
+        if (has_known_size) {
+            return __Pyx_unpack_tuple2_exact(tuple, value1, value2, decref_tuple);
+        }
+        size = __Pyx_PyTuple_GET_SIZE(tuple);
+        if (likely(size == 2)) {
+            return __Pyx_unpack_tuple2_exact(tuple, value1, value2, decref_tuple);
+        }
+        if (size >= 0) {
+            __Pyx_UnpackTupleError(tuple, 2);
+        }
+        return -1;
+    } else {
+        return __Pyx_unpack_tuple2_generic(tuple, value1, value2, has_known_size, decref_tuple);
+    }
+}
 static CYTHON_INLINE int __Pyx_unpack_tuple2_exact(
         PyObject* tuple, PyObject** pvalue1, PyObject** pvalue2, int decref_tuple) {
     PyObject *value1 = NULL, *value2 = NULL;
-#if CYTHON_COMPILING_IN_PYPY
-    value1 = PySequence_ITEM(tuple, 0);  if (unlikely(!value1)) goto bad;
-    value2 = PySequence_ITEM(tuple, 1);  if (unlikely(!value2)) goto bad;
+#if CYTHON_AVOID_BORROWED_REFS || !CYTHON_ASSUME_SAFE_MACROS
+    value1 = __Pyx_PySequence_ITEM(tuple, 0);  if (unlikely(!value1)) goto bad;
+    value2 = __Pyx_PySequence_ITEM(tuple, 1);  if (unlikely(!value2)) goto bad;
 #else
     value1 = PyTuple_GET_ITEM(tuple, 0);  Py_INCREF(value1);
     value2 = PyTuple_GET_ITEM(tuple, 1);  Py_INCREF(value2);
@@ -71090,7 +92045,7 @@ static CYTHON_INLINE int __Pyx_unpack_tuple2_exact(
     *pvalue1 = value1;
     *pvalue2 = value2;
     return 0;
-#if CYTHON_COMPILING_IN_PYPY
+#if CYTHON_AVOID_BORROWED_REFS || !CYTHON_ASSUME_SAFE_MACROS
 bad:
     Py_XDECREF(value1);
     Py_XDECREF(value2);
@@ -71106,7 +92061,7 @@ static int __Pyx_unpack_tuple2_generic(PyObject* tuple, PyObject** pvalue1, PyOb
     iter = PyObject_GetIter(tuple);
     if (unlikely(!iter)) goto bad;
     if (decref_tuple) { Py_DECREF(tuple); tuple = NULL; }
-    iternext = Py_TYPE(iter)->tp_iternext;
+    iternext = __Pyx_PyObject_GetIterNextFunc(iter);
     value1 = iternext(iter); if (unlikely(!value1)) { index = 0; goto unpacking_failed; }
     value2 = iternext(iter); if (unlikely(!value2)) { index = 1; goto unpacking_failed; }
     if (!has_known_size && unlikely(__Pyx_IternextUnpackEndCheck(iternext(iter), 2))) goto bad;
@@ -71126,6 +92081,9 @@ static int __Pyx_unpack_tuple2_generic(PyObject* tuple, PyObject** pvalue1, PyOb
 }
 
 /* dict_iter */
+#if CYTHON_COMPILING_IN_PYPY
+#include <string.h>
+#endif
 static CYTHON_INLINE PyObject* __Pyx_dict_iterator(PyObject* iterable, int is_dict, PyObject* method_name,
                                                    Py_ssize_t* p_orig_length, int* p_source_is_dict) {
     is_dict = is_dict || likely(PyDict_CheckExact(iterable));
@@ -71135,7 +92093,7 @@ static CYTHON_INLINE PyObject* __Pyx_dict_iterator(PyObject* iterable, int is_di
         *p_orig_length = PyDict_Size(iterable);
         Py_INCREF(iterable);
         return iterable;
-#elif PY_MAJOR_VERSION >= 3
+#else
         static PyObject *py_items = NULL, *py_keys = NULL, *py_values = NULL;
         PyObject **pp = NULL;
         if (method_name) {
@@ -71168,55 +92126,104 @@ static CYTHON_INLINE PyObject* __Pyx_dict_iterator(PyObject* iterable, int is_di
         Py_DECREF(iterable);
         return iter;
     }
-    return PyObject_GetIter(iterable);
+    return PyObject_GetIter(iterable);
+}
+#if !CYTHON_COMPILING_IN_PYPY
+static CYTHON_INLINE int __Pyx_dict_iter_next_source_is_dict(
+        PyObject* iter_obj, CYTHON_NCP_UNUSED Py_ssize_t orig_length, CYTHON_NCP_UNUSED Py_ssize_t* ppos,
+        PyObject** pkey, PyObject** pvalue, PyObject** pitem) {
+    PyObject *key, *value;
+    if (unlikely(orig_length != PyDict_Size(iter_obj))) {
+        PyErr_SetString(PyExc_RuntimeError, "dictionary changed size during iteration");
+        return -1;
+    }
+    if (unlikely(!PyDict_Next(iter_obj, ppos, &key, &value))) {
+        return 0;
+    }
+    if (pitem) {
+        PyObject* tuple = PyTuple_New(2);
+        if (unlikely(!tuple)) {
+            return -1;
+        }
+        Py_INCREF(key);
+        Py_INCREF(value);
+        #if CYTHON_ASSUME_SAFE_MACROS
+        PyTuple_SET_ITEM(tuple, 0, key);
+        PyTuple_SET_ITEM(tuple, 1, value);
+        #else
+        if (unlikely(PyTuple_SetItem(tuple, 0, key) < 0)) {
+            Py_DECREF(value);
+            Py_DECREF(tuple);
+            return -1;
+        }
+        if (unlikely(PyTuple_SetItem(tuple, 1, value) < 0)) {
+            Py_DECREF(tuple);
+            return -1;
+        }
+        #endif
+        *pitem = tuple;
+    } else {
+        if (pkey) {
+            Py_INCREF(key);
+            *pkey = key;
+        }
+        if (pvalue) {
+            Py_INCREF(value);
+            *pvalue = value;
+        }
+    }
+    return 1;
 }
+#endif
 static CYTHON_INLINE int __Pyx_dict_iter_next(
         PyObject* iter_obj, CYTHON_NCP_UNUSED Py_ssize_t orig_length, CYTHON_NCP_UNUSED Py_ssize_t* ppos,
         PyObject** pkey, PyObject** pvalue, PyObject** pitem, int source_is_dict) {
     PyObject* next_item;
 #if !CYTHON_COMPILING_IN_PYPY
     if (source_is_dict) {
-        PyObject *key, *value;
-        if (unlikely(orig_length != PyDict_Size(iter_obj))) {
-            PyErr_SetString(PyExc_RuntimeError, "dictionary changed size during iteration");
-            return -1;
-        }
-        if (unlikely(!PyDict_Next(iter_obj, ppos, &key, &value))) {
-            return 0;
-        }
-        if (pitem) {
-            PyObject* tuple = PyTuple_New(2);
-            if (unlikely(!tuple)) {
-                return -1;
-            }
-            Py_INCREF(key);
-            Py_INCREF(value);
-            PyTuple_SET_ITEM(tuple, 0, key);
-            PyTuple_SET_ITEM(tuple, 1, value);
-            *pitem = tuple;
-        } else {
-            if (pkey) {
-                Py_INCREF(key);
-                *pkey = key;
-            }
-            if (pvalue) {
-                Py_INCREF(value);
-                *pvalue = value;
-            }
-        }
-        return 1;
+        int result;
+#if PY_VERSION_HEX >= 0x030d0000 && !CYTHON_COMPILING_IN_LIMITED_API
+        Py_BEGIN_CRITICAL_SECTION(iter_obj);
+#endif
+        result = __Pyx_dict_iter_next_source_is_dict(iter_obj, orig_length, ppos, pkey, pvalue, pitem);
+#if PY_VERSION_HEX >= 0x030d0000 && !CYTHON_COMPILING_IN_LIMITED_API
+        Py_END_CRITICAL_SECTION();
+#endif
+        return result;
     } else if (PyTuple_CheckExact(iter_obj)) {
         Py_ssize_t pos = *ppos;
-        if (unlikely(pos >= PyTuple_GET_SIZE(iter_obj))) return 0;
+        Py_ssize_t tuple_size = __Pyx_PyTuple_GET_SIZE(iter_obj);
+        #if !CYTHON_ASSUME_SAFE_SIZE
+        if (unlikely(tuple_size < 0)) return -1;
+        #endif
+        if (unlikely(pos >= tuple_size)) return 0;
         *ppos = pos + 1;
+        #if CYTHON_ASSUME_SAFE_MACROS
         next_item = PyTuple_GET_ITEM(iter_obj, pos);
+        #else
+        next_item = PyTuple_GetItem(iter_obj, pos);
+        if (unlikely(!next_item)) return -1;
+        #endif
         Py_INCREF(next_item);
     } else if (PyList_CheckExact(iter_obj)) {
         Py_ssize_t pos = *ppos;
-        if (unlikely(pos >= PyList_GET_SIZE(iter_obj))) return 0;
+        Py_ssize_t list_size = __Pyx_PyList_GET_SIZE(iter_obj);
+        #if !CYTHON_ASSUME_SAFE_SIZE
+        if (unlikely(list_size < 0)) return -1;
+        #endif
+        if (unlikely(pos >= list_size)) return 0;
         *ppos = pos + 1;
+        #if CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS
+        next_item = PyList_GetItemRef(iter_obj, pos);
+        if (unlikely(!next_item)) return -1;
+        #elif CYTHON_ASSUME_SAFE_MACROS
         next_item = PyList_GET_ITEM(iter_obj, pos);
         Py_INCREF(next_item);
+        #else
+        next_item = PyList_GetItem(iter_obj, pos);
+        if (unlikely(!next_item)) return -1;
+        Py_INCREF(next_item);
+        #endif
     } else
 #endif
     {
@@ -71238,281 +92245,397 @@ static CYTHON_INLINE int __Pyx_dict_iter_next(
     return 1;
 }
 
-/* PyIntBinop */
+/* PyLongBinop */
 #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
-                    }
-                    CYTHON_FALLTHROUGH;
-                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
-                    }
-                    CYTHON_FALLTHROUGH;
-                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
-                    }
-                    CYTHON_FALLTHROUGH;
-                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
-                    }
-                    CYTHON_FALLTHROUGH;
-                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
-                    }
-                    CYTHON_FALLTHROUGH;
-                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;
+static PyObject* __Pyx_Fallback___Pyx_PyLong_AddObjC(PyObject *op1, PyObject *op2, int inplace) {
+    return (inplace ? PyNumber_InPlaceAdd : PyNumber_Add)(op1, op2);
+}
+#if CYTHON_USE_PYLONG_INTERNALS
+static PyObject* __Pyx_Unpacked___Pyx_PyLong_AddObjC(PyObject *op1, PyObject *op2, long intval, int inplace, int zerodivision_check) {
+    CYTHON_MAYBE_UNUSED_VAR(inplace);
+    CYTHON_UNUSED_VAR(zerodivision_check);
+    const long b = intval;
+    long a, x;
 #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;
+    const PY_LONG_LONG llb = intval;
+    PY_LONG_LONG lla, llx;
 #endif
-                    }
-                    CYTHON_FALLTHROUGH;
-                default: return PyLong_Type.tp_as_number->nb_add(op1, op2);
-            }
+    if (unlikely(__Pyx_PyLong_IsZero(op1))) {
+        return __Pyx_NewRef(op2);
+    }
+    if (unlikely(!__Pyx_PyLong_CompactAsLong(op1, &a))) {
+        const digit* digits = __Pyx_PyLong_Digits(op1);
+        const Py_ssize_t size = __Pyx_PyLong_SignedDigitCount(op1);
+        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
+                }
+                CYTHON_FALLTHROUGH;
+            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
+                }
+                CYTHON_FALLTHROUGH;
+            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
+                }
+                CYTHON_FALLTHROUGH;
+            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
+                }
+                CYTHON_FALLTHROUGH;
+            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
+                }
+                CYTHON_FALLTHROUGH;
+            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
+                }
+                CYTHON_FALLTHROUGH;
+            default: return PyLong_Type.tp_as_number->nb_add(op1, op2);
         }
-                x = a + b;
-            return PyLong_FromLong(x);
+    }
+            x = a + b;
+        return PyLong_FromLong(x);
 #ifdef HAVE_LONG_LONG
-        long_long:
-                llx = lla + llb;
-            return PyLong_FromLongLong(llx);
+    long_long:
+            llx = lla + llb;
+        return PyLong_FromLongLong(llx);
 #endif
+    return __Pyx_Fallback___Pyx_PyLong_AddObjC(op1, op2, inplace);
+    
+    
+}
+#endif
+static PyObject* __Pyx_Float___Pyx_PyLong_AddObjC(PyObject *float_val, long intval, int zerodivision_check) {
+    CYTHON_UNUSED_VAR(zerodivision_check);
+    const long b = intval;
+    double a = __Pyx_PyFloat_AS_DOUBLE(float_val);
+        double result;
         
-        
+        result = ((double)a) + (double)b;
+        return PyFloat_FromDouble(result);
+}
+static CYTHON_INLINE PyObject* __Pyx_PyLong_AddObjC(PyObject *op1, PyObject *op2, long intval, int inplace, int zerodivision_check) {
+    CYTHON_MAYBE_UNUSED_VAR(intval);
+    CYTHON_UNUSED_VAR(zerodivision_check);
+    #if CYTHON_USE_PYLONG_INTERNALS
+    if (likely(PyLong_CheckExact(op1))) {
+        return __Pyx_Unpacked___Pyx_PyLong_AddObjC(op1, op2, intval, inplace, zerodivision_check);
     }
     #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 __Pyx_Float___Pyx_PyLong_AddObjC(op1, intval, zerodivision_check);
     }
-    return (inplace ? PyNumber_InPlaceAdd : PyNumber_Add)(op1, op2);
+    return __Pyx_Fallback___Pyx_PyLong_AddObjC(op1, op2, inplace);
 }
 #endif
 
-/* GetTopmostException */
-#if CYTHON_USE_EXC_INFO_STACK
-static _PyErr_StackItem *
-__Pyx_PyErr_GetTopmostException(PyThreadState *tstate)
-{
-    _PyErr_StackItem *exc_info = tstate->exc_info;
-    while ((exc_info->exc_type == NULL || exc_info->exc_type == Py_None) &&
-           exc_info->previous_item != NULL)
-    {
-        exc_info = exc_info->previous_item;
+/* PyObjectVectorCallKwBuilder */
+#if CYTHON_VECTORCALL
+static int __Pyx_VectorcallBuilder_AddArg(PyObject *key, PyObject *value, PyObject *builder, PyObject **args, int n) {
+    (void)__Pyx_PyObject_FastCallDict;
+    if (__Pyx_PyTuple_SET_ITEM(builder, n, key) != (0)) return -1;
+    Py_INCREF(key);
+    args[n] = value;
+    return 0;
+}
+CYTHON_UNUSED static int __Pyx_VectorcallBuilder_AddArg_Check(PyObject *key, PyObject *value, PyObject *builder, PyObject **args, int n) {
+    (void)__Pyx_VectorcallBuilder_AddArgStr;
+    if (unlikely(!PyUnicode_Check(key))) {
+        PyErr_SetString(PyExc_TypeError, "keywords must be strings");
+        return -1;
     }
-    return exc_info;
+    return __Pyx_VectorcallBuilder_AddArg(key, value, builder, args, n);
 }
-#endif
-
-/* SaveResetException */
-#if CYTHON_FAST_THREAD_STATE
-static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) {
-    #if CYTHON_USE_EXC_INFO_STACK
-    _PyErr_StackItem *exc_info = __Pyx_PyErr_GetTopmostException(tstate);
-    *type = exc_info->exc_type;
-    *value = exc_info->exc_value;
-    *tb = exc_info->exc_traceback;
-    #else
-    *type = tstate->exc_type;
-    *value = tstate->exc_value;
-    *tb = tstate->exc_traceback;
-    #endif
-    Py_XINCREF(*type);
-    Py_XINCREF(*value);
-    Py_XINCREF(*tb);
+static int __Pyx_VectorcallBuilder_AddArgStr(const char *key, PyObject *value, PyObject *builder, PyObject **args, int n) {
+    PyObject *pyKey = PyUnicode_FromString(key);
+    if (!pyKey) return -1;
+    return __Pyx_VectorcallBuilder_AddArg(pyKey, value, builder, args, n);
 }
-static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) {
-    PyObject *tmp_type, *tmp_value, *tmp_tb;
-    #if CYTHON_USE_EXC_INFO_STACK
-    _PyErr_StackItem *exc_info = tstate->exc_info;
-    tmp_type = exc_info->exc_type;
-    tmp_value = exc_info->exc_value;
-    tmp_tb = exc_info->exc_traceback;
-    exc_info->exc_type = type;
-    exc_info->exc_value = value;
-    exc_info->exc_traceback = tb;
-    #else
-    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;
-    #endif
-    Py_XDECREF(tmp_type);
-    Py_XDECREF(tmp_value);
-    Py_XDECREF(tmp_tb);
+#else // CYTHON_VECTORCALL
+CYTHON_UNUSED static int __Pyx_VectorcallBuilder_AddArg_Check(PyObject *key, PyObject *value, PyObject *builder, CYTHON_UNUSED PyObject **args, CYTHON_UNUSED int n) {
+    if (unlikely(!PyUnicode_Check(key))) {
+        PyErr_SetString(PyExc_TypeError, "keywords must be strings");
+        return -1;
+    }
+    return PyDict_SetItem(builder, key, value);
 }
 #endif
 
-/* PyErrExceptionMatches */
-#if CYTHON_FAST_THREAD_STATE
-static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) {
-    Py_ssize_t i, n;
-    n = PyTuple_GET_SIZE(tuple);
-#if PY_MAJOR_VERSION >= 3
-    for (i=0; i<n; i++) {
-        if (exc_type == PyTuple_GET_ITEM(tuple, i)) return 1;
+/* CIntToDigits */
+static const char DIGIT_PAIRS_10[2*10*10+1] = {
+    "00010203040506070809"
+    "10111213141516171819"
+    "20212223242526272829"
+    "30313233343536373839"
+    "40414243444546474849"
+    "50515253545556575859"
+    "60616263646566676869"
+    "70717273747576777879"
+    "80818283848586878889"
+    "90919293949596979899"
+};
+static const char DIGIT_PAIRS_8[2*8*8+1] = {
+    "0001020304050607"
+    "1011121314151617"
+    "2021222324252627"
+    "3031323334353637"
+    "4041424344454647"
+    "5051525354555657"
+    "6061626364656667"
+    "7071727374757677"
+};
+static const char DIGITS_HEX[2*16+1] = {
+    "0123456789abcdef"
+    "0123456789ABCDEF"
+};
+
+/* BuildPyUnicode */
+static PyObject* __Pyx_PyUnicode_BuildFromAscii(Py_ssize_t ulength, const char* chars, int clength,
+                                                int prepend_sign, char padding_char) {
+    PyObject *uval;
+    Py_ssize_t uoffset = ulength - clength;
+#if CYTHON_USE_UNICODE_INTERNALS
+    Py_ssize_t i;
+    void *udata;
+    uval = PyUnicode_New(ulength, 127);
+    if (unlikely(!uval)) return NULL;
+    udata = PyUnicode_DATA(uval);
+    if (uoffset > 0) {
+        i = 0;
+        if (prepend_sign) {
+            __Pyx_PyUnicode_WRITE(PyUnicode_1BYTE_KIND, udata, 0, '-');
+            i++;
+        }
+        for (; i < uoffset; i++) {
+            __Pyx_PyUnicode_WRITE(PyUnicode_1BYTE_KIND, udata, i, padding_char);
+        }
+    }
+    for (i=0; i < clength; i++) {
+        __Pyx_PyUnicode_WRITE(PyUnicode_1BYTE_KIND, udata, uoffset+i, chars[i]);
+    }
+#else
+    {
+        PyObject *sign = NULL, *padding = NULL;
+        uval = NULL;
+        if (uoffset > 0) {
+            prepend_sign = !!prepend_sign;
+            if (uoffset > prepend_sign) {
+                padding = PyUnicode_FromOrdinal(padding_char);
+                if (likely(padding) && uoffset > prepend_sign + 1) {
+                    PyObject *tmp = PySequence_Repeat(padding, uoffset - prepend_sign);
+                    Py_DECREF(padding);
+                    padding = tmp;
+                }
+                if (unlikely(!padding)) goto done_or_error;
+            }
+            if (prepend_sign) {
+                sign = PyUnicode_FromOrdinal('-');
+                if (unlikely(!sign)) goto done_or_error;
+            }
+        }
+        uval = PyUnicode_DecodeASCII(chars, clength, NULL);
+        if (likely(uval) && padding) {
+            PyObject *tmp = PyUnicode_Concat(padding, uval);
+            Py_DECREF(uval);
+            uval = tmp;
+        }
+        if (likely(uval) && sign) {
+            PyObject *tmp = PyUnicode_Concat(sign, uval);
+            Py_DECREF(uval);
+            uval = tmp;
+        }
+done_or_error:
+        Py_XDECREF(padding);
+        Py_XDECREF(sign);
     }
 #endif
-    for (i=0; i<n; i++) {
-        if (__Pyx_PyErr_GivenExceptionMatches(exc_type, PyTuple_GET_ITEM(tuple, i))) return 1;
+    return uval;
+}
+
+/* COrdinalToPyUnicode */
+static CYTHON_INLINE int __Pyx_CheckUnicodeValue(int value) {
+    return value <= 1114111;
+}
+static PyObject* __Pyx_PyUnicode_FromOrdinal_Padded(int value, Py_ssize_t ulength, char padding_char) {
+    if (likely(ulength <= 250)) {
+        char chars[256];
+        if (value <= 255) {
+            memset(chars, padding_char, (size_t) (ulength - 1));
+            chars[ulength-1] = (char) value;
+            return PyUnicode_DecodeLatin1(chars, ulength, NULL);
+        }
+        char *cpos = chars + sizeof(chars);
+        if (value < 0x800) {
+            *--cpos = (char) (0x80 | (value & 0x3f));
+            value >>= 6;
+            *--cpos = (char) (0xc0 | (value & 0x1f));
+        } else if (value < 0x10000) {
+            *--cpos = (char) (0x80 | (value & 0x3f));
+            value >>= 6;
+            *--cpos = (char) (0x80 | (value & 0x3f));
+            value >>= 6;
+            *--cpos = (char) (0xe0 | (value & 0x0f));
+        } else {
+            *--cpos = (char) (0x80 | (value & 0x3f));
+            value >>= 6;
+            *--cpos = (char) (0x80 | (value & 0x3f));
+            value >>= 6;
+            *--cpos = (char) (0x80 | (value & 0x3f));
+            value >>= 6;
+            *--cpos = (char) (0xf0 | (value & 0x07));
+        }
+        cpos -= ulength;
+        memset(cpos, padding_char, (size_t) (ulength - 1));
+        return PyUnicode_DecodeUTF8(cpos, chars + sizeof(chars) - cpos, NULL);
+    }
+    if (value <= 127 && CYTHON_USE_UNICODE_INTERNALS) {
+        const char chars[1] = {(char) value};
+        return __Pyx_PyUnicode_BuildFromAscii(ulength, chars, 1, 0, padding_char);
+    }
+    {
+        PyObject *uchar, *padding_uchar, *padding, *result;
+        padding_uchar = PyUnicode_FromOrdinal(padding_char);
+        if (unlikely(!padding_uchar)) return NULL;
+        padding = PySequence_Repeat(padding_uchar, ulength - 1);
+        Py_DECREF(padding_uchar);
+        if (unlikely(!padding)) return NULL;
+        uchar = PyUnicode_FromOrdinal(value);
+        if (unlikely(!uchar)) {
+            Py_DECREF(padding);
+            return NULL;
+        }
+        result = PyUnicode_Concat(padding, uchar);
+        Py_DECREF(padding);
+        Py_DECREF(uchar);
+        return result;
     }
-    return 0;
-}
-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;
-    if (unlikely(PyTuple_Check(err)))
-        return __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err);
-    return __Pyx_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);
+/* CIntToPyUnicode */
+static CYTHON_INLINE PyObject* __Pyx_PyUnicode_From_Py_ssize_t(Py_ssize_t value, Py_ssize_t width, char padding_char, char format_char) {
+    char digits[sizeof(Py_ssize_t)*3+2];
+    char *dpos, *end = digits + sizeof(Py_ssize_t)*3+2;
+    const char *hex_digits = DIGITS_HEX;
+    Py_ssize_t length, ulength;
+    int prepend_sign, last_one_off;
+    Py_ssize_t remaining;
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
 #endif
-    PyErr_NormalizeException(&local_type, &local_value, &local_tb);
-#if CYTHON_FAST_THREAD_STATE
-    if (unlikely(tstate->curexc_type))
-#else
-    if (unlikely(PyErr_Occurred()))
+    const Py_ssize_t neg_one = (Py_ssize_t) -1, const_zero = (Py_ssize_t) 0;
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic pop
 #endif
-        goto bad;
-    #if PY_MAJOR_VERSION >= 3
-    if (local_tb) {
-        if (unlikely(PyException_SetTraceback(local_value, local_tb) < 0))
-            goto bad;
+    const int is_unsigned = neg_one > const_zero;
+    if (format_char == 'c') {
+        if (unlikely(!(is_unsigned || value == 0 || value > 0) ||
+                     !(sizeof(value) <= 2 || value & ~ (Py_ssize_t) 0x01fffff || __Pyx_CheckUnicodeValue((int) value)))) {
+            PyErr_SetString(PyExc_OverflowError, "%c arg not in range(0x110000)");
+            return NULL;
+        }
+        if (width <= 1) {
+            return PyUnicode_FromOrdinal((int) value);
+        }
+        return __Pyx_PyUnicode_FromOrdinal_Padded((int) value, width, padding_char);
+    }
+    if (format_char == 'X') {
+        hex_digits += 16;
+        format_char = 'x';
+    }
+    remaining = value;
+    last_one_off = 0;
+    dpos = end;
+    do {
+        int digit_pos;
+        switch (format_char) {
+        case 'o':
+            digit_pos = abs((int)(remaining % (8*8)));
+            remaining = (Py_ssize_t) (remaining / (8*8));
+            dpos -= 2;
+            memcpy(dpos, DIGIT_PAIRS_8 + digit_pos * 2, 2);
+            last_one_off = (digit_pos < 8);
+            break;
+        case 'd':
+            digit_pos = abs((int)(remaining % (10*10)));
+            remaining = (Py_ssize_t) (remaining / (10*10));
+            dpos -= 2;
+            memcpy(dpos, DIGIT_PAIRS_10 + digit_pos * 2, 2);
+            last_one_off = (digit_pos < 10);
+            break;
+        case 'x':
+            *(--dpos) = hex_digits[abs((int)(remaining % 16))];
+            remaining = (Py_ssize_t) (remaining / 16);
+            break;
+        default:
+            assert(0);
+            break;
+        }
+    } while (unlikely(remaining != 0));
+    assert(!last_one_off || *dpos == '0');
+    dpos += last_one_off;
+    length = end - dpos;
+    ulength = length;
+    prepend_sign = 0;
+    if (!is_unsigned && value <= neg_one) {
+        if (padding_char == ' ' || width <= length + 1) {
+            *(--dpos) = '-';
+            ++length;
+        } else {
+            prepend_sign = 1;
+        }
+        ++ulength;
     }
-    #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
-    #if CYTHON_USE_EXC_INFO_STACK
-    {
-        _PyErr_StackItem *exc_info = tstate->exc_info;
-        tmp_type = exc_info->exc_type;
-        tmp_value = exc_info->exc_value;
-        tmp_tb = exc_info->exc_traceback;
-        exc_info->exc_type = local_type;
-        exc_info->exc_value = local_value;
-        exc_info->exc_traceback = local_tb;
+    if (width > ulength) {
+        ulength = width;
     }
-    #else
-    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;
-    #endif
-    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;
+    if (ulength == 1) {
+        return PyUnicode_FromOrdinal(*dpos);
+    }
+    return __Pyx_PyUnicode_BuildFromAscii(ulength, dpos, (int) length, prepend_sign, padding_char);
 }
 
 /* SliceTupleAndList */
@@ -71532,142 +92655,86 @@ static CYTHON_INLINE void __Pyx_crop_slice(Py_ssize_t* _start, Py_ssize_t* _stop
     *_start = start;
     *_stop = stop;
 }
-static CYTHON_INLINE void __Pyx_copy_object_array(PyObject** CYTHON_RESTRICT src, PyObject** CYTHON_RESTRICT dest, Py_ssize_t length) {
-    PyObject *v;
-    Py_ssize_t i;
-    for (i = 0; i < length; i++) {
-        v = dest[i] = src[i];
-        Py_INCREF(v);
-    }
+static CYTHON_INLINE PyObject* __Pyx_PyTuple_GetSlice(
+            PyObject* src, Py_ssize_t start, Py_ssize_t stop) {
+    Py_ssize_t length = PyTuple_GET_SIZE(src);
+    __Pyx_crop_slice(&start, &stop, &length);
+    return __Pyx_PyTuple_FromArray(((PyTupleObject*)src)->ob_item + start, length);
 }
-static CYTHON_INLINE PyObject* __Pyx_PyList_GetSlice(
+static CYTHON_INLINE PyObject* __Pyx_PyList_GetSlice_locked(
             PyObject* src, Py_ssize_t start, Py_ssize_t stop) {
-    PyObject* dest;
     Py_ssize_t length = PyList_GET_SIZE(src);
     __Pyx_crop_slice(&start, &stop, &length);
-    if (unlikely(length <= 0))
+    if (length <= 0) {
         return PyList_New(0);
-    dest = PyList_New(length);
-    if (unlikely(!dest))
-        return NULL;
-    __Pyx_copy_object_array(
-        ((PyListObject*)src)->ob_item + start,
-        ((PyListObject*)dest)->ob_item,
-        length);
-    return dest;
+    }
+    return __Pyx_PyList_FromArray(((PyListObject*)src)->ob_item + start, length);
 }
-static CYTHON_INLINE PyObject* __Pyx_PyTuple_GetSlice(
+static CYTHON_INLINE PyObject* __Pyx_PyList_GetSlice(
             PyObject* src, Py_ssize_t start, Py_ssize_t stop) {
-    PyObject* dest;
-    Py_ssize_t length = PyTuple_GET_SIZE(src);
-    __Pyx_crop_slice(&start, &stop, &length);
-    if (unlikely(length <= 0))
-        return PyTuple_New(0);
-    dest = PyTuple_New(length);
-    if (unlikely(!dest))
-        return NULL;
-    __Pyx_copy_object_array(
-        ((PyTupleObject*)src)->ob_item + start,
-        ((PyTupleObject*)dest)->ob_item,
-        length);
-    return dest;
+    PyObject *result;
+    __Pyx_BEGIN_CRITICAL_SECTION(src);
+    result = __Pyx_PyList_GetSlice_locked(src, start, stop);
+    __Pyx_END_CRITICAL_SECTION();
+    return result;
 }
-#endif
+#endif // CYTHON_COMPILING_IN_CPYTHON
 
-/* UnpackUnboundCMethod */
-static int __Pyx_TryUnpackUnboundCMethod(__Pyx_CachedCFunction* target) {
-    PyObject *method;
-    method = __Pyx_PyObject_GetAttrStr(target->type, *target->method_name);
-    if (unlikely(!method))
-        return -1;
-    target->method = method;
+/* CallUnboundCMethod0 */
 #if CYTHON_COMPILING_IN_CPYTHON
-    #if PY_MAJOR_VERSION >= 3
-    if (likely(__Pyx_TypeCheck(method, &PyMethodDescr_Type)))
-    #endif
-    {
-        PyMethodDescrObject *descr = (PyMethodDescrObject*) method;
-        target->func = descr->d_method->ml_meth;
-        target->flag = descr->d_method->ml_flags & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_STACKLESS);
+static CYTHON_INLINE PyObject* __Pyx_CallUnboundCMethod0(__Pyx_CachedCFunction* cfunc, PyObject* self) {
+    int was_initialized = __Pyx_CachedCFunction_GetAndSetInitializing(cfunc);
+    if (likely(was_initialized == 2 && cfunc->func)) {
+        if (likely(cfunc->flag == METH_NOARGS))
+            return __Pyx_CallCFunction(cfunc, self, NULL);
+        if (likely(cfunc->flag == METH_FASTCALL))
+            return __Pyx_CallCFunctionFast(cfunc, self, NULL, 0);
+        if (cfunc->flag == (METH_FASTCALL | METH_KEYWORDS))
+            return __Pyx_CallCFunctionFastWithKeywords(cfunc, self, NULL, 0, NULL);
+        if (likely(cfunc->flag == (METH_VARARGS | METH_KEYWORDS)))
+            return __Pyx_CallCFunctionWithKeywords(cfunc, self, __pyx_mstate_global->__pyx_empty_tuple, NULL);
+        if (cfunc->flag == METH_VARARGS)
+            return __Pyx_CallCFunction(cfunc, self, __pyx_mstate_global->__pyx_empty_tuple);
+        return __Pyx__CallUnboundCMethod0(cfunc, self);
+    }
+#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING
+    else if (unlikely(was_initialized == 1)) {
+        __Pyx_CachedCFunction tmp_cfunc = {
+#ifndef __cplusplus
+            0
+#endif
+        };
+        tmp_cfunc.type = cfunc->type;
+        tmp_cfunc.method_name = cfunc->method_name;
+        return __Pyx__CallUnboundCMethod0(&tmp_cfunc, self);
     }
 #endif
-    return 0;
+    PyObject *result = __Pyx__CallUnboundCMethod0(cfunc, self);
+    __Pyx_CachedCFunction_SetFinishedInitializing(cfunc);
+    return result;
 }
-
-/* CallUnboundCMethod0 */
+#endif
 static PyObject* __Pyx__CallUnboundCMethod0(__Pyx_CachedCFunction* cfunc, PyObject* self) {
-    PyObject *args, *result = NULL;
+    PyObject *result;
     if (unlikely(!cfunc->method) && unlikely(__Pyx_TryUnpackUnboundCMethod(cfunc) < 0)) return NULL;
-#if CYTHON_ASSUME_SAFE_MACROS
-    args = PyTuple_New(1);
-    if (unlikely(!args)) goto bad;
-    Py_INCREF(self);
-    PyTuple_SET_ITEM(args, 0, self);
-#else
-    args = PyTuple_Pack(1, self);
-    if (unlikely(!args)) goto bad;
-#endif
-    result = __Pyx_PyObject_Call(cfunc->method, args, NULL);
-    Py_DECREF(args);
-bad:
+    result = __Pyx_PyObject_CallOneArg(cfunc->method, self);
     return result;
 }
 
 /* py_dict_keys */
 static CYTHON_INLINE PyObject* __Pyx_PyDict_Keys(PyObject* d) {
-    if (PY_MAJOR_VERSION >= 3)
-        return __Pyx_CallUnboundCMethod0(&__pyx_umethod_PyDict_Type_keys, d);
-    else
-        return PyDict_Keys(d);
+    return __Pyx_CallUnboundCMethod0(&__pyx_mstate_global->__pyx_umethod_PyDict_Type_keys, d);
 }
 
-/* PyNumberPow2 */
-static PyObject* __Pyx__PyNumber_PowerOf2(PyObject *two, PyObject *exp, PyObject *none, int inplace) {
-#if !CYTHON_COMPILING_IN_PYPY
-    Py_ssize_t shiftby;
-#if PY_MAJOR_VERSION < 3
-    if (likely(PyInt_CheckExact(exp))) {
-        shiftby = PyInt_AS_LONG(exp);
-    } else
-#endif
-    if (likely(PyLong_CheckExact(exp))) {
-        #if CYTHON_USE_PYLONG_INTERNALS
-        const Py_ssize_t size = Py_SIZE(exp);
-        if (likely(size == 1)) {
-            shiftby = ((PyLongObject*)exp)->ob_digit[0];
-        } else if (size == 0) {
-            return PyInt_FromLong(1L);
-        } else if (unlikely(size < 0)) {
-            goto fallback;
-        } else {
-            shiftby = PyLong_AsSsize_t(exp);
-        }
-        #else
-        shiftby = PyLong_AsSsize_t(exp);
-        #endif
-    } else {
-        goto fallback;
-    }
-    if (likely(shiftby >= 0)) {
-        if ((size_t)shiftby <= sizeof(long) * 8 - 2) {
-            long value = 1L << shiftby;
-            return PyInt_FromLong(value);
-#ifdef HAVE_LONG_LONG
-        } else if ((size_t)shiftby <= sizeof(unsigned PY_LONG_LONG) * 8 - 1) {
-            unsigned PY_LONG_LONG value = ((unsigned PY_LONG_LONG)1) << shiftby;
-            return PyLong_FromUnsignedLongLong(value);
-#endif
-        } else {
-            PyObject *one = PyInt_FromLong(1L);
-            if (unlikely(!one)) return NULL;
-            return PyNumber_Lshift(one, exp);
-        }
-    } else if (shiftby == -1 && PyErr_Occurred()) {
-        PyErr_Clear();
-    }
-fallback:
-#endif
-    return (inplace ? PyNumber_InPlacePower : PyNumber_Power)(two, exp, none);
+/* RaiseUnexpectedTypeError */
+static int
+__Pyx_RaiseUnexpectedTypeError(const char *expected, PyObject *obj)
+{
+    __Pyx_TypeName obj_type_name = __Pyx_PyType_GetFullyQualifiedName(Py_TYPE(obj));
+    PyErr_Format(PyExc_TypeError, "Expected %s, got " __Pyx_FMT_TYPENAME,
+                 expected, obj_type_name);
+    __Pyx_DECREF_TypeName(obj_type_name);
+    return 0;
 }
 
 /* SliceObject */
@@ -71675,46 +92742,9 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_GetSlice(PyObject* obj,
         Py_ssize_t cstart, Py_ssize_t cstop,
         PyObject** _py_start, PyObject** _py_stop, PyObject** _py_slice,
         int has_cstart, int has_cstop, CYTHON_UNUSED int wraparound) {
+    __Pyx_TypeName obj_type_name;
 #if CYTHON_USE_TYPE_SLOTS
-    PyMappingMethods* mp;
-#if PY_MAJOR_VERSION < 3
-    PySequenceMethods* ms = Py_TYPE(obj)->tp_as_sequence;
-    if (likely(ms && ms->sq_slice)) {
-        if (!has_cstart) {
-            if (_py_start && (*_py_start != Py_None)) {
-                cstart = __Pyx_PyIndex_AsSsize_t(*_py_start);
-                if ((cstart == (Py_ssize_t)-1) && PyErr_Occurred()) goto bad;
-            } else
-                cstart = 0;
-        }
-        if (!has_cstop) {
-            if (_py_stop && (*_py_stop != Py_None)) {
-                cstop = __Pyx_PyIndex_AsSsize_t(*_py_stop);
-                if ((cstop == (Py_ssize_t)-1) && PyErr_Occurred()) goto bad;
-            } else
-                cstop = PY_SSIZE_T_MAX;
-        }
-        if (wraparound && unlikely((cstart < 0) | (cstop < 0)) && likely(ms->sq_length)) {
-            Py_ssize_t l = ms->sq_length(obj);
-            if (likely(l >= 0)) {
-                if (cstop < 0) {
-                    cstop += l;
-                    if (cstop < 0) cstop = 0;
-                }
-                if (cstart < 0) {
-                    cstart += l;
-                    if (cstart < 0) cstart = 0;
-                }
-            } else {
-                if (!PyErr_ExceptionMatches(PyExc_OverflowError))
-                    goto bad;
-                PyErr_Clear();
-            }
-        }
-        return ms->sq_slice(obj, cstart, cstop);
-    }
-#endif
-    mp = Py_TYPE(obj)->tp_as_mapping;
+    PyMappingMethods* mp = Py_TYPE(obj)->tp_as_mapping;
     if (likely(mp && mp->mp_subscript))
 #endif
     {
@@ -71729,399 +92759,84 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_GetSlice(PyObject* obj,
                 py_start = *_py_start;
             } else {
                 if (has_cstart) {
-                    owned_start = py_start = PyInt_FromSsize_t(cstart);
-                    if (unlikely(!py_start)) goto bad;
-                } else
-                    py_start = Py_None;
-            }
-            if (_py_stop) {
-                py_stop = *_py_stop;
-            } else {
-                if (has_cstop) {
-                    owned_stop = py_stop = PyInt_FromSsize_t(cstop);
-                    if (unlikely(!py_stop)) {
-                        Py_XDECREF(owned_start);
-                        goto bad;
-                    }
-                } else
-                    py_stop = Py_None;
-            }
-            py_slice = PySlice_New(py_start, py_stop, Py_None);
-            Py_XDECREF(owned_start);
-            Py_XDECREF(owned_stop);
-            if (unlikely(!py_slice)) goto bad;
-        }
-#if CYTHON_USE_TYPE_SLOTS
-        result = mp->mp_subscript(obj, py_slice);
-#else
-        result = PyObject_GetItem(obj, py_slice);
-#endif
-        if (!_py_slice) {
-            Py_DECREF(py_slice);
-        }
-        return result;
-    }
-    PyErr_Format(PyExc_TypeError,
-        "'%.200s' object is unsliceable", Py_TYPE(obj)->tp_name);
-bad:
-    return NULL;
-}
-
-/* PyIntCompare */
-static CYTHON_INLINE PyObject* __Pyx_PyInt_EqObjC(PyObject *op1, PyObject *op2, CYTHON_UNUSED long intval, CYTHON_UNUSED long 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))) {
-        int unequal;
-        unsigned long uintval;
-        Py_ssize_t size = Py_SIZE(op1);
-        const digit* digits = ((PyLongObject*)op1)->ob_digit;
-        if (intval == 0) {
-            if (size == 0) Py_RETURN_TRUE; else Py_RETURN_FALSE;
-        } else if (intval < 0) {
-            if (size >= 0)
-                Py_RETURN_FALSE;
-            intval = -intval;
-            size = -size;
-        } else {
-            if (size <= 0)
-                Py_RETURN_FALSE;
-        }
-        uintval = (unsigned long) intval;
-#if PyLong_SHIFT * 4 < SIZEOF_LONG*8
-        if (uintval >> (PyLong_SHIFT * 4)) {
-            unequal = (size != 5) || (digits[0] != (uintval & (unsigned long) PyLong_MASK))
-                 | (digits[1] != ((uintval >> (1 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[2] != ((uintval >> (2 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[3] != ((uintval >> (3 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[4] != ((uintval >> (4 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK));
-        } else
-#endif
-#if PyLong_SHIFT * 3 < SIZEOF_LONG*8
-        if (uintval >> (PyLong_SHIFT * 3)) {
-            unequal = (size != 4) || (digits[0] != (uintval & (unsigned long) PyLong_MASK))
-                 | (digits[1] != ((uintval >> (1 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[2] != ((uintval >> (2 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[3] != ((uintval >> (3 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK));
-        } else
-#endif
-#if PyLong_SHIFT * 2 < SIZEOF_LONG*8
-        if (uintval >> (PyLong_SHIFT * 2)) {
-            unequal = (size != 3) || (digits[0] != (uintval & (unsigned long) PyLong_MASK))
-                 | (digits[1] != ((uintval >> (1 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[2] != ((uintval >> (2 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK));
-        } else
-#endif
-#if PyLong_SHIFT * 1 < SIZEOF_LONG*8
-        if (uintval >> (PyLong_SHIFT * 1)) {
-            unequal = (size != 2) || (digits[0] != (uintval & (unsigned long) PyLong_MASK))
-                 | (digits[1] != ((uintval >> (1 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK));
-        } else
-#endif
-            unequal = (size != 1) || (((unsigned long) digits[0]) != (uintval & (unsigned long) PyLong_MASK));
-        if (unequal == 0) 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));
-}
-
-/* PyIntBinop */
-#if !CYTHON_COMPILING_IN_PYPY
-static PyObject* __Pyx_PyInt_RemainderObjC(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 = a % b;
-            x += ((x != 0) & ((x ^ b) < 0)) * b;
-            return PyInt_FromLong(x);
-    }
-    #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
-                    }
-                    CYTHON_FALLTHROUGH;
-                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
-                    }
-                    CYTHON_FALLTHROUGH;
-                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
-                    }
-                    CYTHON_FALLTHROUGH;
-                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
-                    }
-                    CYTHON_FALLTHROUGH;
-                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
-                    }
-                    CYTHON_FALLTHROUGH;
-                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
-                    }
-                    CYTHON_FALLTHROUGH;
-                default: return PyLong_Type.tp_as_number->nb_remainder(op1, op2);
-            }
-        }
-                x = a % b;
-                x += ((x != 0) & ((x ^ b) < 0)) * b;
-            return PyLong_FromLong(x);
-#ifdef HAVE_LONG_LONG
-        long_long:
-                llx = lla % llb;
-                llx += ((llx != 0) & ((llx ^ llb) < 0)) * llb;
-            return PyLong_FromLongLong(llx);
-#endif
-        
-        
-    }
-    #endif
-    return (inplace ? PyNumber_InPlaceRemainder : PyNumber_Remainder)(op1, op2);
-}
-#endif
-
-/* 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;
-#if CYTHON_USE_UNICODE_INTERNALS
-            Py_hash_t hash1, hash2;
-            hash1 = ((PyBytesObject*)s1)->ob_shash;
-            hash2 = ((PyBytesObject*)s2)->ob_shash;
-            if (hash1 != hash2 && hash1 != -1 && hash2 != -1) {
-                return (equals == Py_NE);
-            }
-#endif
-            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;
-        }
-#if CYTHON_USE_UNICODE_INTERNALS
-        {
-            Py_hash_t hash1, hash2;
-        #if CYTHON_PEP393_ENABLED
-            hash1 = ((PyASCIIObject*)s1)->hash;
-            hash2 = ((PyASCIIObject*)s2)->hash;
-        #else
-            hash1 = ((PyUnicodeObject*)s1)->hash;
-            hash2 = ((PyUnicodeObject*)s2)->hash;
-        #endif
-            if (hash1 != hash2 && hash1 != -1 && hash2 != -1) {
-                goto return_ne;
+                    owned_start = py_start = PyLong_FromSsize_t(cstart);
+                    if (unlikely(!py_start)) goto bad;
+                } else
+                    py_start = Py_None;
+            }
+            if (_py_stop) {
+                py_stop = *_py_stop;
+            } else {
+                if (has_cstop) {
+                    owned_stop = py_stop = PyLong_FromSsize_t(cstop);
+                    if (unlikely(!py_stop)) {
+                        Py_XDECREF(owned_start);
+                        goto bad;
+                    }
+                } else
+                    py_stop = Py_None;
             }
+            py_slice = PySlice_New(py_start, py_stop, Py_None);
+            Py_XDECREF(owned_start);
+            Py_XDECREF(owned_stop);
+            if (unlikely(!py_slice)) goto bad;
         }
+#if CYTHON_USE_TYPE_SLOTS
+        result = mp->mp_subscript(obj, py_slice);
+#else
+        result = PyObject_GetItem(obj, py_slice);
 #endif
-        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);
+        if (!_py_slice) {
+            Py_DECREF(py_slice);
         }
-    } 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_MAJOR_VERSION < 3
-        Py_XDECREF(owned_ref);
-        #endif
-        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
+    obj_type_name = __Pyx_PyType_GetFullyQualifiedName(Py_TYPE(obj));
+    PyErr_Format(PyExc_TypeError,
+        "'" __Pyx_FMT_TYPENAME "' object is unsliceable", obj_type_name);
+    __Pyx_DECREF_TypeName(obj_type_name);
+bad:
+    return NULL;
 }
 
 /* SetItemInt */
 static int __Pyx_SetItemInt_Generic(PyObject *o, PyObject *j, PyObject *v) {
     int r;
-    if (!j) return -1;
+    if (unlikely(!j)) return -1;
     r = PyObject_SetItem(o, j, v);
     Py_DECREF(j);
     return r;
 }
 static CYTHON_INLINE int __Pyx_SetItemInt_Fast(PyObject *o, Py_ssize_t i, PyObject *v, 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 CYTHON_ASSUME_SAFE_MACROS && CYTHON_ASSUME_SAFE_SIZE && !CYTHON_AVOID_BORROWED_REFS && CYTHON_USE_TYPE_SLOTS
     if (is_list || PyList_CheckExact(o)) {
         Py_ssize_t n = (!wraparound) ? i : ((likely(i >= 0)) ? i : i + PyList_GET_SIZE(o));
         if ((!boundscheck) || likely(__Pyx_is_valid_index(n, PyList_GET_SIZE(o)))) {
-            PyObject* old = PyList_GET_ITEM(o, n);
             Py_INCREF(v);
+#if CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS
+            PyList_SetItem(o, n, v);
+#else
+            PyObject* old = PyList_GET_ITEM(o, n);
             PyList_SET_ITEM(o, n, v);
             Py_DECREF(old);
+#endif
             return 1;
         }
     } else {
-        PySequenceMethods *m = Py_TYPE(o)->tp_as_sequence;
-        if (likely(m && m->sq_ass_item)) {
-            if (wraparound && unlikely(i < 0) && likely(m->sq_length)) {
-                Py_ssize_t l = m->sq_length(o);
+        PyMappingMethods *mm = Py_TYPE(o)->tp_as_mapping;
+        PySequenceMethods *sm = Py_TYPE(o)->tp_as_sequence;
+        if (mm && mm->mp_ass_subscript) {
+            int r;
+            PyObject *key = PyLong_FromSsize_t(i);
+            if (unlikely(!key)) return -1;
+            r = mm->mp_ass_subscript(o, key, v);
+            Py_DECREF(key);
+            return r;
+        }
+        if (likely(sm && sm->sq_ass_item)) {
+            if (wraparound && unlikely(i < 0) && likely(sm->sq_length)) {
+                Py_ssize_t l = sm->sq_length(o);
                 if (likely(l >= 0)) {
                     i += l;
                 } else {
@@ -72130,88 +92845,30 @@ static CYTHON_INLINE int __Pyx_SetItemInt_Fast(PyObject *o, Py_ssize_t i, PyObje
                     PyErr_Clear();
                 }
             }
-            return m->sq_ass_item(o, i, v);
+            return sm->sq_ass_item(o, i, v);
         }
     }
 #else
-#if CYTHON_COMPILING_IN_PYPY
-    if (is_list || (PySequence_Check(o) && !PyDict_Check(o)))
-#else
-    if (is_list || PySequence_Check(o))
-#endif
+    if (is_list || !PyMapping_Check(o))
     {
         return PySequence_SetItem(o, i, v);
     }
 #endif
-    return __Pyx_SetItemInt_Generic(o, PyInt_FromSsize_t(i), v);
-}
-
-/* WriteUnraisableException */
-static void __Pyx_WriteUnraisable(const char *name, CYTHON_UNUSED int clineno,
-                                  CYTHON_UNUSED int lineno, CYTHON_UNUSED const char *filename,
-                                  int full_traceback, CYTHON_UNUSED int nogil) {
-    PyObject *old_exc, *old_val, *old_tb;
-    PyObject *ctx;
-    __Pyx_PyThreadState_declare
-#ifdef WITH_THREAD
-    PyGILState_STATE state;
-    if (nogil)
-        state = PyGILState_Ensure();
-#ifdef _MSC_VER
-    else state = (PyGILState_STATE)-1;
-#endif
-#endif
-    __Pyx_PyThreadState_assign
-    __Pyx_ErrFetch(&old_exc, &old_val, &old_tb);
-    if (full_traceback) {
-        Py_XINCREF(old_exc);
-        Py_XINCREF(old_val);
-        Py_XINCREF(old_tb);
-        __Pyx_ErrRestore(old_exc, old_val, old_tb);
-        PyErr_PrintEx(1);
-    }
-    #if PY_MAJOR_VERSION < 3
-    ctx = PyString_FromString(name);
-    #else
-    ctx = PyUnicode_FromString(name);
-    #endif
-    __Pyx_ErrRestore(old_exc, old_val, old_tb);
-    if (!ctx) {
-        PyErr_WriteUnraisable(Py_None);
-    } else {
-        PyErr_WriteUnraisable(ctx);
-        Py_DECREF(ctx);
-    }
-#ifdef WITH_THREAD
-    if (nogil)
-        PyGILState_Release(state);
-#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(__Pyx_TypeCheck(obj, type)))
-        return 1;
-    PyErr_Format(PyExc_TypeError, "Cannot convert %.200s to %.200s",
-                 Py_TYPE(obj)->tp_name, type->tp_name);
-    return 0;
+    return __Pyx_SetItemInt_Generic(o, PyLong_FromSsize_t(i), v);
 }
 
 /* TypeImport */
-#ifndef __PYX_HAVE_RT_ImportType
-#define __PYX_HAVE_RT_ImportType
-static PyTypeObject *__Pyx_ImportType(PyObject *module, const char *module_name, const char *class_name,
-    size_t size, enum __Pyx_ImportType_CheckSize check_size)
+#ifndef __PYX_HAVE_RT_ImportType_3_1_5
+#define __PYX_HAVE_RT_ImportType_3_1_5
+static PyTypeObject *__Pyx_ImportType_3_1_5(PyObject *module, const char *module_name, const char *class_name,
+    size_t size, size_t alignment, enum __Pyx_ImportType_CheckSize_3_1_5 check_size)
 {
     PyObject *result = 0;
-    char warning[200];
     Py_ssize_t basicsize;
-#ifdef Py_LIMITED_API
+    Py_ssize_t itemsize;
+#if defined(Py_LIMITED_API) || (defined(CYTHON_COMPILING_IN_LIMITED_API) && CYTHON_COMPILING_IN_LIMITED_API)
     PyObject *py_basicsize;
+    PyObject *py_itemsize;
 #endif
     result = PyObject_GetAttrString(module, class_name);
     if (!result)
@@ -72222,9 +92879,13 @@ static PyTypeObject *__Pyx_ImportType(PyObject *module, const char *module_name,
             module_name, class_name);
         goto bad;
     }
-#ifndef Py_LIMITED_API
+#if !( defined(Py_LIMITED_API) || (defined(CYTHON_COMPILING_IN_LIMITED_API) && CYTHON_COMPILING_IN_LIMITED_API) )
     basicsize = ((PyTypeObject *)result)->tp_basicsize;
+    itemsize = ((PyTypeObject *)result)->tp_itemsize;
 #else
+    if (size == 0) {
+        return (PyTypeObject *)result;
+    }
     py_basicsize = PyObject_GetAttrString(result, "__basicsize__");
     if (!py_basicsize)
         goto bad;
@@ -72233,27 +92894,44 @@ static PyTypeObject *__Pyx_ImportType(PyObject *module, const char *module_name,
     py_basicsize = 0;
     if (basicsize == (Py_ssize_t)-1 && PyErr_Occurred())
         goto bad;
+    py_itemsize = PyObject_GetAttrString(result, "__itemsize__");
+    if (!py_itemsize)
+        goto bad;
+    itemsize = PyLong_AsSsize_t(py_itemsize);
+    Py_DECREF(py_itemsize);
+    py_itemsize = 0;
+    if (itemsize == (Py_ssize_t)-1 && PyErr_Occurred())
+        goto bad;
 #endif
-    if ((size_t)basicsize < size) {
+    if (itemsize) {
+        if (size % alignment) {
+            alignment = size % alignment;
+        }
+        if (itemsize < (Py_ssize_t)alignment)
+            itemsize = (Py_ssize_t)alignment;
+    }
+    if ((size_t)(basicsize + itemsize) < size) {
         PyErr_Format(PyExc_ValueError,
             "%.200s.%.200s size changed, may indicate binary incompatibility. "
             "Expected %zd from C header, got %zd from PyObject",
-            module_name, class_name, size, basicsize);
+            module_name, class_name, size, basicsize+itemsize);
         goto bad;
     }
-    if (check_size == __Pyx_ImportType_CheckSize_Error && (size_t)basicsize != size) {
+    if (check_size == __Pyx_ImportType_CheckSize_Error_3_1_5 &&
+            ((size_t)basicsize > size || (size_t)(basicsize + itemsize) < size)) {
         PyErr_Format(PyExc_ValueError,
             "%.200s.%.200s size changed, may indicate binary incompatibility. "
-            "Expected %zd from C header, got %zd from PyObject",
-            module_name, class_name, size, basicsize);
+            "Expected %zd from C header, got %zd-%zd from PyObject",
+            module_name, class_name, size, basicsize, basicsize+itemsize);
         goto bad;
     }
-    else if (check_size == __Pyx_ImportType_CheckSize_Warn && (size_t)basicsize > size) {
-        PyOS_snprintf(warning, sizeof(warning),
-            "%s.%s size changed, may indicate binary incompatibility. "
-            "Expected %zd from C header, got %zd from PyObject",
-            module_name, class_name, size, basicsize);
-        if (PyErr_WarnEx(NULL, warning, 0) < 0) goto bad;
+    else if (check_size == __Pyx_ImportType_CheckSize_Warn_3_1_5 && (size_t)basicsize > size) {
+        if (PyErr_WarnFormat(NULL, 0,
+                "%.200s.%.200s size changed, may indicate binary incompatibility. "
+                "Expected %zd from C header, got %zd from PyObject",
+                module_name, class_name, size, basicsize) < 0) {
+            goto bad;
+        }
     }
     return (PyTypeObject *)result;
 bad:
@@ -72262,126 +92940,551 @@ static PyTypeObject *__Pyx_ImportType(PyObject *module, const char *module_name,
 }
 #endif
 
-/* CalculateMetaclass */
-static PyObject *__Pyx_CalculateMetaclass(PyTypeObject *metaclass, PyObject *bases) {
-    Py_ssize_t i, nbases = PyTuple_GET_SIZE(bases);
-    for (i=0; i < nbases; i++) {
-        PyTypeObject *tmptype;
-        PyObject *tmp = PyTuple_GET_ITEM(bases, i);
-        tmptype = Py_TYPE(tmp);
-#if PY_MAJOR_VERSION < 3
-        if (tmptype == &PyClass_Type)
-            continue;
-#endif
-        if (!metaclass) {
-            metaclass = tmptype;
-            continue;
+/* LimitedApiGetTypeDict */
+#if CYTHON_COMPILING_IN_LIMITED_API
+static Py_ssize_t __Pyx_GetTypeDictOffset(void) {
+    PyObject *tp_dictoffset_o;
+    Py_ssize_t tp_dictoffset;
+    tp_dictoffset_o = PyObject_GetAttrString((PyObject*)(&PyType_Type), "__dictoffset__");
+    if (unlikely(!tp_dictoffset_o)) return -1;
+    tp_dictoffset = PyLong_AsSsize_t(tp_dictoffset_o);
+    Py_DECREF(tp_dictoffset_o);
+    if (unlikely(tp_dictoffset == 0)) {
+        PyErr_SetString(
+            PyExc_TypeError,
+            "'type' doesn't have a dictoffset");
+        return -1;
+    } else if (unlikely(tp_dictoffset < 0)) {
+        PyErr_SetString(
+            PyExc_TypeError,
+            "'type' has an unexpected negative dictoffset. "
+            "Please report this as Cython bug");
+        return -1;
+    }
+    return tp_dictoffset;
+}
+static PyObject *__Pyx_GetTypeDict(PyTypeObject *tp) {
+    static Py_ssize_t tp_dictoffset = 0;
+    if (unlikely(tp_dictoffset == 0)) {
+        tp_dictoffset = __Pyx_GetTypeDictOffset();
+        if (unlikely(tp_dictoffset == -1 && PyErr_Occurred())) {
+            tp_dictoffset = 0; // try again next time?
+            return NULL;
         }
-        if (PyType_IsSubtype(metaclass, tmptype))
-            continue;
-        if (PyType_IsSubtype(tmptype, metaclass)) {
-            metaclass = tmptype;
-            continue;
+    }
+    return *(PyObject**)((char*)tp + tp_dictoffset);
+}
+#endif
+
+/* SetItemOnTypeDict */
+static int __Pyx__SetItemOnTypeDict(PyTypeObject *tp, PyObject *k, PyObject *v) {
+    int result;
+    PyObject *tp_dict;
+#if CYTHON_COMPILING_IN_LIMITED_API
+    tp_dict = __Pyx_GetTypeDict(tp);
+    if (unlikely(!tp_dict)) return -1;
+#else
+    tp_dict = tp->tp_dict;
+#endif
+    result = PyDict_SetItem(tp_dict, k, v);
+    if (likely(!result)) {
+        PyType_Modified(tp);
+        if (unlikely(PyObject_HasAttr(v, __pyx_mstate_global->__pyx_n_u_set_name))) {
+            PyObject *setNameResult = PyObject_CallMethodObjArgs(v, __pyx_mstate_global->__pyx_n_u_set_name,  (PyObject *) tp, k, NULL);
+            if (!setNameResult) return -1;
+            Py_DECREF(setNameResult);
         }
-        PyErr_SetString(PyExc_TypeError,
-                        "metaclass conflict: "
-                        "the metaclass of a derived class "
-                        "must be a (non-strict) subclass "
-                        "of the metaclasses of all its bases");
-        return NULL;
     }
-    if (!metaclass) {
-#if PY_MAJOR_VERSION < 3
-        metaclass = &PyClass_Type;
+    return result;
+}
+
+/* FixUpExtensionType */
+static int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject *type) {
+#if __PYX_LIMITED_VERSION_HEX > 0x030900B1
+    CYTHON_UNUSED_VAR(spec);
+    CYTHON_UNUSED_VAR(type);
+    CYTHON_UNUSED_VAR(__Pyx__SetItemOnTypeDict);
 #else
-        metaclass = &PyType_Type;
+    const PyType_Slot *slot = spec->slots;
+    int changed = 0;
+#if !CYTHON_COMPILING_IN_LIMITED_API
+    while (slot && slot->slot && slot->slot != Py_tp_members)
+        slot++;
+    if (slot && slot->slot == Py_tp_members) {
+#if !CYTHON_COMPILING_IN_CPYTHON
+        const
+#endif  // !CYTHON_COMPILING_IN_CPYTHON)
+            PyMemberDef *memb = (PyMemberDef*) slot->pfunc;
+        while (memb && memb->name) {
+            if (memb->name[0] == '_' && memb->name[1] == '_') {
+                if (strcmp(memb->name, "__weaklistoffset__") == 0) {
+                    assert(memb->type == T_PYSSIZET);
+                    assert(memb->flags == READONLY);
+                    type->tp_weaklistoffset = memb->offset;
+                    changed = 1;
+                }
+                else if (strcmp(memb->name, "__dictoffset__") == 0) {
+                    assert(memb->type == T_PYSSIZET);
+                    assert(memb->flags == READONLY);
+                    type->tp_dictoffset = memb->offset;
+                    changed = 1;
+                }
+#if CYTHON_METH_FASTCALL
+                else if (strcmp(memb->name, "__vectorcalloffset__") == 0) {
+                    assert(memb->type == T_PYSSIZET);
+                    assert(memb->flags == READONLY);
+#if PY_VERSION_HEX >= 0x030800b4
+                    type->tp_vectorcall_offset = memb->offset;
+#else
+                    type->tp_print = (printfunc) memb->offset;
 #endif
+                    changed = 1;
+                }
+#endif  // CYTHON_METH_FASTCALL
+#if !CYTHON_COMPILING_IN_PYPY
+                else if (strcmp(memb->name, "__module__") == 0) {
+                    PyObject *descr;
+                    assert(memb->type == T_OBJECT);
+                    assert(memb->flags == 0 || memb->flags == READONLY);
+                    descr = PyDescr_NewMember(type, memb);
+                    if (unlikely(!descr))
+                        return -1;
+                    int set_item_result = PyDict_SetItem(type->tp_dict, PyDescr_NAME(descr), descr);
+                    Py_DECREF(descr);
+                    if (unlikely(set_item_result < 0)) {
+                        return -1;
+                    }
+                    changed = 1;
+                }
+#endif  // !CYTHON_COMPILING_IN_PYPY
+            }
+            memb++;
+        }
     }
-    Py_INCREF((PyObject*) metaclass);
-    return (PyObject*) metaclass;
+#endif  // !CYTHON_COMPILING_IN_LIMITED_API
+#if !CYTHON_COMPILING_IN_PYPY
+    slot = spec->slots;
+    while (slot && slot->slot && slot->slot != Py_tp_getset)
+        slot++;
+    if (slot && slot->slot == Py_tp_getset) {
+        PyGetSetDef *getset = (PyGetSetDef*) slot->pfunc;
+        while (getset && getset->name) {
+            if (getset->name[0] == '_' && getset->name[1] == '_' && strcmp(getset->name, "__module__") == 0) {
+                PyObject *descr = PyDescr_NewGetSet(type, getset);
+                if (unlikely(!descr))
+                    return -1;
+                #if CYTHON_COMPILING_IN_LIMITED_API
+                PyObject *pyname = PyUnicode_FromString(getset->name);
+                if (unlikely(!pyname)) {
+                    Py_DECREF(descr);
+                    return -1;
+                }
+                int set_item_result = __Pyx_SetItemOnTypeDict(type, pyname, descr);
+                Py_DECREF(pyname);
+                #else
+                CYTHON_UNUSED_VAR(__Pyx__SetItemOnTypeDict);
+                int set_item_result = PyDict_SetItem(type->tp_dict, PyDescr_NAME(descr), descr);
+                #endif
+                Py_DECREF(descr);
+                if (unlikely(set_item_result < 0)) {
+                    return -1;
+                }
+                changed = 1;
+            }
+            ++getset;
+        }
+    }
+#endif  // !CYTHON_COMPILING_IN_PYPY
+    if (changed)
+        PyType_Modified(type);
+#endif  // PY_VERSION_HEX > 0x030900B1
+    return 0;
+}
+
+/* FetchSharedCythonModule */
+static PyObject *__Pyx_FetchSharedCythonABIModule(void) {
+    return __Pyx_PyImport_AddModuleRef(__PYX_ABI_MODULE_NAME);
+}
+
+/* dict_setdefault */
+static CYTHON_INLINE PyObject *__Pyx_PyDict_SetDefault(PyObject *d, PyObject *key, PyObject *default_value,
+                                                       int is_safe_type) {
+    PyObject* value;
+    CYTHON_MAYBE_UNUSED_VAR(is_safe_type);
+#if CYTHON_COMPILING_IN_LIMITED_API
+    value = PyObject_CallMethod(d, "setdefault", "OO", key, default_value);
+#elif PY_VERSION_HEX >= 0x030d0000
+    PyDict_SetDefaultRef(d, key, default_value, &value);
+#else
+    value = PyDict_SetDefault(d, key, default_value);
+    if (unlikely(!value)) return NULL;
+    Py_INCREF(value);
+#endif
+    return value;
 }
 
 /* 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);
+#if __PYX_LIMITED_VERSION_HEX < 0x030C0000
+static PyObject* __Pyx_PyType_FromMetaclass(PyTypeObject *metaclass, PyObject *module, PyType_Spec *spec, PyObject *bases) {
+    PyObject *result = __Pyx_PyType_FromModuleAndSpec(module, spec, bases);
+    if (result && metaclass) {
+        PyObject *old_tp = (PyObject*)Py_TYPE(result);
+    Py_INCREF((PyObject*)metaclass);
+#if __PYX_LIMITED_VERSION_HEX >= 0x03090000
+        Py_SET_TYPE(result, metaclass);
+#else
+        result->ob_type = metaclass;
+#endif
+        Py_DECREF(old_tp);
+    }
+    return result;
+}
+#else
+#define __Pyx_PyType_FromMetaclass(me, mo, s, b) PyType_FromMetaclass(me, mo, s, b)
+#endif
+static int __Pyx_VerifyCachedType(PyObject *cached_type,
+                               const char *name,
+                               Py_ssize_t expected_basicsize) {
+    Py_ssize_t basicsize;
+    if (!PyType_Check(cached_type)) {
+        PyErr_Format(PyExc_TypeError,
+            "Shared Cython type %.200s is not a type object", name);
+        return -1;
+    }
+    if (expected_basicsize == 0) {
+        return 0; // size is inherited, nothing useful to check
+    }
+#if CYTHON_COMPILING_IN_LIMITED_API
+    PyObject *py_basicsize;
+    py_basicsize = PyObject_GetAttrString(cached_type, "__basicsize__");
+    if (unlikely(!py_basicsize)) return -1;
+    basicsize = PyLong_AsSsize_t(py_basicsize);
+    Py_DECREF(py_basicsize);
+    py_basicsize = NULL;
+    if (unlikely(basicsize == (Py_ssize_t)-1) && PyErr_Occurred()) return -1;
+#else
+    basicsize = ((PyTypeObject*) cached_type)->tp_basicsize;
+#endif
+    if (basicsize != expected_basicsize) {
+        PyErr_Format(PyExc_TypeError,
+            "Shared Cython type %.200s has the wrong size, try recompiling",
+            name);
+        return -1;
+    }
+    return 0;
+}
+static PyTypeObject *__Pyx_FetchCommonTypeFromSpec(PyTypeObject *metaclass, PyObject *module, PyType_Spec *spec, PyObject *bases) {
+    PyObject *abi_module = NULL, *cached_type = NULL, *abi_module_dict, *new_cached_type, *py_object_name;
+    int get_item_ref_result;
+    const char* object_name = strrchr(spec->name, '.');
+    object_name = object_name ? object_name+1 : spec->name;
+    py_object_name = PyUnicode_FromString(object_name);
+    if (!py_object_name) return NULL;
+    abi_module = __Pyx_FetchSharedCythonABIModule();
+    if (!abi_module) goto done;
+    abi_module_dict = PyModule_GetDict(abi_module);
+    if (!abi_module_dict) goto done;
+    get_item_ref_result = __Pyx_PyDict_GetItemRef(abi_module_dict, py_object_name, &cached_type);
+    if (get_item_ref_result == 1) {
+        if (__Pyx_VerifyCachedType(
+              cached_type,
+              object_name,
+              spec->basicsize) < 0) {
             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 done;
+    } else if (unlikely(get_item_ref_result == -1)) {
+        goto bad;
+    }
+    CYTHON_UNUSED_VAR(module);
+    cached_type = __Pyx_PyType_FromMetaclass(metaclass, abi_module, spec, bases);
+    if (unlikely(!cached_type)) goto bad;
+    if (unlikely(__Pyx_fix_up_extension_type_from_spec(spec, (PyTypeObject *) cached_type) < 0)) goto bad;
+    new_cached_type = __Pyx_PyDict_SetDefault(abi_module_dict, py_object_name, cached_type, 1);
+    if (unlikely(new_cached_type != cached_type)) {
+        if (unlikely(!new_cached_type)) goto bad;
+        Py_DECREF(cached_type);
+        cached_type = new_cached_type;
+        if (__Pyx_VerifyCachedType(
+                cached_type,
+                object_name,
+                spec->basicsize) < 0) {
             goto bad;
         }
+        goto done;
     } 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;
+        Py_DECREF(new_cached_type);
     }
 done:
-    Py_DECREF(fake_module);
-    return cached_type;
+    Py_XDECREF(abi_module);
+    Py_DECREF(py_object_name);
+    assert(cached_type == NULL || PyType_Check(cached_type));
+    return (PyTypeObject *) cached_type;
 bad:
     Py_XDECREF(cached_type);
     cached_type = NULL;
     goto done;
 }
 
-/* CythonFunction */
-#include <structmember.h>
+/* CommonTypesMetaclass */
+static PyObject* __pyx_CommonTypesMetaclass_get_module(CYTHON_UNUSED PyObject *self, CYTHON_UNUSED void* context) {
+    return PyUnicode_FromString(__PYX_ABI_MODULE_NAME);
+}
+static PyGetSetDef __pyx_CommonTypesMetaclass_getset[] = {
+    {"__module__", __pyx_CommonTypesMetaclass_get_module, NULL, NULL, NULL},
+    {0, 0, 0, 0, 0}
+};
+static PyType_Slot __pyx_CommonTypesMetaclass_slots[] = {
+    {Py_tp_getset, (void *)__pyx_CommonTypesMetaclass_getset},
+    {0, 0}
+};
+static PyType_Spec __pyx_CommonTypesMetaclass_spec = {
+    __PYX_TYPE_MODULE_PREFIX "_common_types_metatype",
+    0,
+    0,
+#if PY_VERSION_HEX >= 0x030A0000
+    Py_TPFLAGS_IMMUTABLETYPE |
+    Py_TPFLAGS_DISALLOW_INSTANTIATION |
+#endif
+    Py_TPFLAGS_DEFAULT,
+    __pyx_CommonTypesMetaclass_slots
+};
+static int __pyx_CommonTypesMetaclass_init(PyObject *module) {
+    __pyx_mstatetype *mstate = __Pyx_PyModule_GetState(module);
+    PyObject *bases = PyTuple_Pack(1, &PyType_Type);
+    if (unlikely(!bases)) {
+        return -1;
+    }
+    mstate->__pyx_CommonTypesMetaclassType = __Pyx_FetchCommonTypeFromSpec(NULL, module, &__pyx_CommonTypesMetaclass_spec, bases);
+    Py_DECREF(bases);
+    if (unlikely(mstate->__pyx_CommonTypesMetaclassType == NULL)) {
+        return -1;
+    }
+    return 0;
+}
+
+/* CallTypeTraverse */
+#if !CYTHON_USE_TYPE_SPECS || (!CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x03090000)
+#else
+static int __Pyx_call_type_traverse(PyObject *o, int always_call, visitproc visit, void *arg) {
+    #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x03090000
+    if (__Pyx_get_runtime_version() < 0x03090000) return 0;
+    #endif
+    if (!always_call) {
+        PyTypeObject *base = __Pyx_PyObject_GetSlot(o, tp_base, PyTypeObject*);
+        unsigned long flags = PyType_GetFlags(base);
+        if (flags & Py_TPFLAGS_HEAPTYPE) {
+            return 0;
+        }
+    }
+    Py_VISIT((PyObject*)Py_TYPE(o));
+    return 0;
+}
+#endif
+
+/* PyMethodNew */
+#if CYTHON_COMPILING_IN_LIMITED_API
+static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ) {
+    PyObject *result;
+    CYTHON_UNUSED_VAR(typ);
+    if (!self)
+        return __Pyx_NewRef(func);
+    #if __PYX_LIMITED_VERSION_HEX >= 0x030C0000
+    {
+        PyObject *args[] = {func, self};
+        result = PyObject_Vectorcall(__pyx_mstate_global->__Pyx_CachedMethodType, args, 2, NULL);
+    }
+    #else
+    result = PyObject_CallFunctionObjArgs(__pyx_mstate_global->__Pyx_CachedMethodType, func, self, NULL);
+    #endif
+    return result;
+}
+#else
+static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ) {
+    CYTHON_UNUSED_VAR(typ);
+    if (!self)
+        return __Pyx_NewRef(func);
+    return PyMethod_New(func, self);
+}
+#endif
+
+/* PyVectorcallFastCallDict */
+#if CYTHON_METH_FASTCALL && (CYTHON_VECTORCALL || CYTHON_BACKPORT_VECTORCALL)
+static PyObject *__Pyx_PyVectorcall_FastCallDict_kw(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw)
+{
+    PyObject *res = NULL;
+    PyObject *kwnames;
+    PyObject **newargs;
+    PyObject **kwvalues;
+    Py_ssize_t i, pos;
+    size_t j;
+    PyObject *key, *value;
+    unsigned long keys_are_strings;
+    #if !CYTHON_ASSUME_SAFE_SIZE
+    Py_ssize_t nkw = PyDict_Size(kw);
+    if (unlikely(nkw == -1)) return NULL;
+    #else
+    Py_ssize_t nkw = PyDict_GET_SIZE(kw);
+    #endif
+    newargs = (PyObject **)PyMem_Malloc((nargs + (size_t)nkw) * sizeof(args[0]));
+    if (unlikely(newargs == NULL)) {
+        PyErr_NoMemory();
+        return NULL;
+    }
+    for (j = 0; j < nargs; j++) newargs[j] = args[j];
+    kwnames = PyTuple_New(nkw);
+    if (unlikely(kwnames == NULL)) {
+        PyMem_Free(newargs);
+        return NULL;
+    }
+    kwvalues = newargs + nargs;
+    pos = i = 0;
+    keys_are_strings = Py_TPFLAGS_UNICODE_SUBCLASS;
+    while (PyDict_Next(kw, &pos, &key, &value)) {
+        keys_are_strings &=
+        #if CYTHON_COMPILING_IN_LIMITED_API
+            PyType_GetFlags(Py_TYPE(key));
+        #else
+            Py_TYPE(key)->tp_flags;
+        #endif
+        Py_INCREF(key);
+        Py_INCREF(value);
+        #if !CYTHON_ASSUME_SAFE_MACROS
+        if (unlikely(PyTuple_SetItem(kwnames, i, key) < 0)) goto cleanup;
+        #else
+        PyTuple_SET_ITEM(kwnames, i, key);
+        #endif
+        kwvalues[i] = value;
+        i++;
+    }
+    if (unlikely(!keys_are_strings)) {
+        PyErr_SetString(PyExc_TypeError, "keywords must be strings");
+        goto cleanup;
+    }
+    res = vc(func, newargs, nargs, kwnames);
+cleanup:
+    Py_DECREF(kwnames);
+    for (i = 0; i < nkw; i++)
+        Py_DECREF(kwvalues[i]);
+    PyMem_Free(newargs);
+    return res;
+}
+static CYTHON_INLINE PyObject *__Pyx_PyVectorcall_FastCallDict(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw)
+{
+    Py_ssize_t kw_size =
+        likely(kw == NULL) ?
+        0 :
+#if !CYTHON_ASSUME_SAFE_SIZE
+        PyDict_Size(kw);
+#else
+        PyDict_GET_SIZE(kw);
+#endif
+    if (kw_size == 0) {
+        return vc(func, args, nargs, NULL);
+    }
+#if !CYTHON_ASSUME_SAFE_SIZE
+    else if (unlikely(kw_size == -1)) {
+        return NULL;
+    }
+#endif
+    return __Pyx_PyVectorcall_FastCallDict_kw(func, vc, args, nargs, kw);
+}
+#endif
+
+/* CythonFunctionShared */
+#if CYTHON_COMPILING_IN_LIMITED_API
+static CYTHON_INLINE int __Pyx__IsSameCyOrCFunctionNoMethod(PyObject *func, void (*cfunc)(void)) {
+    if (__Pyx_CyFunction_Check(func)) {
+        return PyCFunction_GetFunction(((__pyx_CyFunctionObject*)func)->func) == (PyCFunction) cfunc;
+    } else if (PyCFunction_Check(func)) {
+        return PyCFunction_GetFunction(func) == (PyCFunction) cfunc;
+    }
+    return 0;
+}
+static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void (*cfunc)(void)) {
+    if ((PyObject*)Py_TYPE(func) == __pyx_mstate_global->__Pyx_CachedMethodType) {
+        int result;
+        PyObject *newFunc = PyObject_GetAttr(func, __pyx_mstate_global->__pyx_n_u_func);
+        if (unlikely(!newFunc)) {
+            PyErr_Clear(); // It's only an optimization, so don't throw an error
+            return 0;
+        }
+        result = __Pyx__IsSameCyOrCFunctionNoMethod(newFunc, cfunc);
+        Py_DECREF(newFunc);
+        return result;
+    }
+    return __Pyx__IsSameCyOrCFunctionNoMethod(func, cfunc);
+}
+#else
+static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void (*cfunc)(void)) {
+    if (PyMethod_Check(func)) {
+        func = PyMethod_GET_FUNCTION(func);
+    }
+    return __Pyx_CyOrPyCFunction_Check(func) && __Pyx_CyOrPyCFunction_GET_FUNCTION(func) == (PyCFunction) cfunc;
+}
+#endif
+static CYTHON_INLINE void __Pyx__CyFunction_SetClassObj(__pyx_CyFunctionObject* f, PyObject* classobj) {
+#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API
+    __Pyx_Py_XDECREF_SET(
+        __Pyx_CyFunction_GetClassObj(f),
+            ((classobj) ? __Pyx_NewRef(classobj) : NULL));
+#else
+    __Pyx_Py_XDECREF_SET(
+        ((PyCMethodObject *) (f))->mm_class,
+        (PyTypeObject*)((classobj) ? __Pyx_NewRef(classobj) : NULL));
+#endif
+}
 static PyObject *
-__Pyx_CyFunction_get_doc(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *closure)
+__Pyx_CyFunction_get_doc_locked(__pyx_CyFunctionObject *op)
 {
     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);
+#if CYTHON_COMPILING_IN_LIMITED_API
+        op->func_doc = PyObject_GetAttrString(op->func, "__doc__");
+        if (unlikely(!op->func_doc)) return NULL;
 #else
-            op->func_doc = PyString_FromString(op->func.m_ml->ml_doc);
-#endif
+        if (((PyCFunctionObject*)op)->m_ml->ml_doc) {
+            op->func_doc = PyUnicode_FromString(((PyCFunctionObject*)op)->m_ml->ml_doc);
             if (unlikely(op->func_doc == NULL))
                 return NULL;
         } else {
             Py_INCREF(Py_None);
             return Py_None;
         }
+#endif
     }
     Py_INCREF(op->func_doc);
     return op->func_doc;
 }
+static PyObject *
+__Pyx_CyFunction_get_doc(__pyx_CyFunctionObject *op, void *closure) {
+    PyObject *result;
+    CYTHON_UNUSED_VAR(closure);
+    __Pyx_BEGIN_CRITICAL_SECTION(op);
+    result = __Pyx_CyFunction_get_doc_locked(op);
+    __Pyx_END_CRITICAL_SECTION();
+    return result;
+}
 static int
-__Pyx_CyFunction_set_doc(__pyx_CyFunctionObject *op, PyObject *value, CYTHON_UNUSED void *context)
+__Pyx_CyFunction_set_doc(__pyx_CyFunctionObject *op, PyObject *value, void *context)
 {
-    PyObject *tmp = op->func_doc;
+    CYTHON_UNUSED_VAR(context);
     if (value == NULL) {
         value = Py_None;
     }
     Py_INCREF(value);
-    op->func_doc = value;
-    Py_XDECREF(tmp);
+    __Pyx_BEGIN_CRITICAL_SECTION(op);
+    __Pyx_Py_XDECREF_SET(op->func_doc, value);
+    __Pyx_END_CRITICAL_SECTION();
     return 0;
 }
 static PyObject *
-__Pyx_CyFunction_get_name(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *context)
+__Pyx_CyFunction_get_name_locked(__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);
+#if CYTHON_COMPILING_IN_LIMITED_API
+        op->func_name = PyObject_GetAttrString(op->func, "__name__");
 #else
-        op->func_name = PyString_InternFromString(op->func.m_ml->ml_name);
+        op->func_name = PyUnicode_InternFromString(((PyCFunctionObject*)op)->m_ml->ml_name);
 #endif
         if (unlikely(op->func_name == NULL))
             return NULL;
@@ -72389,64 +93492,59 @@ __Pyx_CyFunction_get_name(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *contex
     Py_INCREF(op->func_name);
     return op->func_name;
 }
+static PyObject *
+__Pyx_CyFunction_get_name(__pyx_CyFunctionObject *op, void *context)
+{
+    PyObject *result = NULL;
+    CYTHON_UNUSED_VAR(context);
+    __Pyx_BEGIN_CRITICAL_SECTION(op);
+    result = __Pyx_CyFunction_get_name_locked(op);
+    __Pyx_END_CRITICAL_SECTION();
+    return result;
+}
 static int
-__Pyx_CyFunction_set_name(__pyx_CyFunctionObject *op, PyObject *value, CYTHON_UNUSED void *context)
+__Pyx_CyFunction_set_name(__pyx_CyFunctionObject *op, PyObject *value, void *context)
 {
-    PyObject *tmp;
-#if PY_MAJOR_VERSION >= 3
-    if (unlikely(value == NULL || !PyUnicode_Check(value)))
-#else
-    if (unlikely(value == NULL || !PyString_Check(value)))
-#endif
-    {
+    CYTHON_UNUSED_VAR(context);
+    if (unlikely(value == NULL || !PyUnicode_Check(value))) {
         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);
+    __Pyx_BEGIN_CRITICAL_SECTION(op);
+    __Pyx_Py_XDECREF_SET(op->func_name, value);
+    __Pyx_END_CRITICAL_SECTION();
     return 0;
 }
 static PyObject *
-__Pyx_CyFunction_get_qualname(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *context)
+__Pyx_CyFunction_get_qualname(__pyx_CyFunctionObject *op, void *context)
 {
+    CYTHON_UNUSED_VAR(context);
+    PyObject *result;
+    __Pyx_BEGIN_CRITICAL_SECTION(op);
     Py_INCREF(op->func_qualname);
-    return op->func_qualname;
+    result = op->func_qualname;
+    __Pyx_END_CRITICAL_SECTION();
+    return result;
 }
 static int
-__Pyx_CyFunction_set_qualname(__pyx_CyFunctionObject *op, PyObject *value, CYTHON_UNUSED void *context)
+__Pyx_CyFunction_set_qualname(__pyx_CyFunctionObject *op, PyObject *value, void *context)
 {
-    PyObject *tmp;
-#if PY_MAJOR_VERSION >= 3
-    if (unlikely(value == NULL || !PyUnicode_Check(value)))
-#else
-    if (unlikely(value == NULL || !PyString_Check(value)))
-#endif
-    {
+    CYTHON_UNUSED_VAR(context);
+    if (unlikely(value == NULL || !PyUnicode_Check(value))) {
         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);
+    __Pyx_BEGIN_CRITICAL_SECTION(op);
+    __Pyx_Py_XDECREF_SET(op->func_qualname, value);
+    __Pyx_END_CRITICAL_SECTION();
     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, CYTHON_UNUSED void *context)
+__Pyx_CyFunction_get_dict_locked(__pyx_CyFunctionObject *op)
 {
     if (unlikely(op->func_dict == NULL)) {
         op->func_dict = PyDict_New();
@@ -72456,10 +93554,20 @@ __Pyx_CyFunction_get_dict(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *contex
     Py_INCREF(op->func_dict);
     return op->func_dict;
 }
+static PyObject *
+__Pyx_CyFunction_get_dict(__pyx_CyFunctionObject *op, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+    PyObject *result;
+    __Pyx_BEGIN_CRITICAL_SECTION(op);
+    result = __Pyx_CyFunction_get_dict_locked(op);
+    __Pyx_END_CRITICAL_SECTION();
+    return result;
+}
 static int
-__Pyx_CyFunction_set_dict(__pyx_CyFunctionObject *op, PyObject *value, CYTHON_UNUSED void *context)
+__Pyx_CyFunction_set_dict(__pyx_CyFunctionObject *op, PyObject *value, void *context)
 {
-    PyObject *tmp;
+    CYTHON_UNUSED_VAR(context);
     if (unlikely(value == NULL)) {
         PyErr_SetString(PyExc_TypeError,
                "function's dictionary may not be deleted");
@@ -72470,28 +93578,32 @@ __Pyx_CyFunction_set_dict(__pyx_CyFunctionObject *op, PyObject *value, CYTHON_UN
                "setting function's dictionary to a non-dict");
         return -1;
     }
-    tmp = op->func_dict;
     Py_INCREF(value);
-    op->func_dict = value;
-    Py_XDECREF(tmp);
+    __Pyx_BEGIN_CRITICAL_SECTION(op);
+    __Pyx_Py_XDECREF_SET(op->func_dict, value);
+    __Pyx_END_CRITICAL_SECTION();
     return 0;
 }
 static PyObject *
-__Pyx_CyFunction_get_globals(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *context)
+__Pyx_CyFunction_get_globals(__pyx_CyFunctionObject *op, void *context)
 {
+    CYTHON_UNUSED_VAR(context);
     Py_INCREF(op->func_globals);
     return op->func_globals;
 }
 static PyObject *
-__Pyx_CyFunction_get_closure(CYTHON_UNUSED __pyx_CyFunctionObject *op, CYTHON_UNUSED void *context)
+__Pyx_CyFunction_get_closure(__pyx_CyFunctionObject *op, void *context)
 {
+    CYTHON_UNUSED_VAR(op);
+    CYTHON_UNUSED_VAR(context);
     Py_INCREF(Py_None);
     return Py_None;
 }
 static PyObject *
-__Pyx_CyFunction_get_code(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *context)
+__Pyx_CyFunction_get_code(__pyx_CyFunctionObject *op, void *context)
 {
     PyObject* result = (op->func_code) ? op->func_code : Py_None;
+    CYTHON_UNUSED_VAR(context);
     Py_INCREF(result);
     return result;
 }
@@ -72507,10 +93619,10 @@ __Pyx_CyFunction_init_defaults(__pyx_CyFunctionObject *op) {
     op->defaults_kwdict = PyTuple_GET_ITEM(res, 1);
     Py_INCREF(op->defaults_kwdict);
     #else
-    op->defaults_tuple = PySequence_ITEM(res, 0);
+    op->defaults_tuple = __Pyx_PySequence_ITEM(res, 0);
     if (unlikely(!op->defaults_tuple)) result = -1;
     else {
-        op->defaults_kwdict = PySequence_ITEM(res, 1);
+        op->defaults_kwdict = __Pyx_PySequence_ITEM(res, 1);
         if (unlikely(!op->defaults_kwdict)) result = -1;
     }
     #endif
@@ -72518,27 +93630,29 @@ __Pyx_CyFunction_init_defaults(__pyx_CyFunctionObject *op) {
     return result;
 }
 static int
-__Pyx_CyFunction_set_defaults(__pyx_CyFunctionObject *op, PyObject* value, CYTHON_UNUSED void *context) {
-    PyObject* tmp;
+__Pyx_CyFunction_set_defaults(__pyx_CyFunctionObject *op, PyObject* value, void *context) {
+    CYTHON_UNUSED_VAR(context);
     if (!value) {
         value = Py_None;
-    } else if (value != Py_None && !PyTuple_Check(value)) {
+    } else if (unlikely(value != Py_None && !PyTuple_Check(value))) {
         PyErr_SetString(PyExc_TypeError,
                         "__defaults__ must be set to a tuple object");
         return -1;
     }
+    PyErr_WarnEx(PyExc_RuntimeWarning, "changes to cyfunction.__defaults__ will not "
+                 "currently affect the values used in function calls", 1);
     Py_INCREF(value);
-    tmp = op->defaults_tuple;
-    op->defaults_tuple = value;
-    Py_XDECREF(tmp);
+    __Pyx_BEGIN_CRITICAL_SECTION(op);
+    __Pyx_Py_XDECREF_SET(op->defaults_tuple, value);
+    __Pyx_END_CRITICAL_SECTION();
     return 0;
 }
 static PyObject *
-__Pyx_CyFunction_get_defaults(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *context) {
+__Pyx_CyFunction_get_defaults_locked(__pyx_CyFunctionObject *op) {
     PyObject* result = op->defaults_tuple;
     if (unlikely(!result)) {
         if (op->defaults_getter) {
-            if (__Pyx_CyFunction_init_defaults(op) < 0) return NULL;
+            if (unlikely(__Pyx_CyFunction_init_defaults(op) < 0)) return NULL;
             result = op->defaults_tuple;
         } else {
             result = Py_None;
@@ -72547,28 +93661,39 @@ __Pyx_CyFunction_get_defaults(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *co
     Py_INCREF(result);
     return result;
 }
+static PyObject *
+__Pyx_CyFunction_get_defaults(__pyx_CyFunctionObject *op, void *context) {
+    PyObject* result = NULL;
+    CYTHON_UNUSED_VAR(context);
+    __Pyx_BEGIN_CRITICAL_SECTION(op);
+    result = __Pyx_CyFunction_get_defaults_locked(op);
+    __Pyx_END_CRITICAL_SECTION();
+    return result;
+}
 static int
-__Pyx_CyFunction_set_kwdefaults(__pyx_CyFunctionObject *op, PyObject* value, CYTHON_UNUSED void *context) {
-    PyObject* tmp;
+__Pyx_CyFunction_set_kwdefaults(__pyx_CyFunctionObject *op, PyObject* value, void *context) {
+    CYTHON_UNUSED_VAR(context);
     if (!value) {
         value = Py_None;
-    } else if (value != Py_None && !PyDict_Check(value)) {
+    } else if (unlikely(value != Py_None && !PyDict_Check(value))) {
         PyErr_SetString(PyExc_TypeError,
                         "__kwdefaults__ must be set to a dict object");
         return -1;
     }
+    PyErr_WarnEx(PyExc_RuntimeWarning, "changes to cyfunction.__kwdefaults__ will not "
+                 "currently affect the values used in function calls", 1);
     Py_INCREF(value);
-    tmp = op->defaults_kwdict;
-    op->defaults_kwdict = value;
-    Py_XDECREF(tmp);
+    __Pyx_BEGIN_CRITICAL_SECTION(op);
+    __Pyx_Py_XDECREF_SET(op->defaults_kwdict, value);
+    __Pyx_END_CRITICAL_SECTION();
     return 0;
 }
 static PyObject *
-__Pyx_CyFunction_get_kwdefaults(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *context) {
+__Pyx_CyFunction_get_kwdefaults_locked(__pyx_CyFunctionObject *op) {
     PyObject* result = op->defaults_kwdict;
     if (unlikely(!result)) {
         if (op->defaults_getter) {
-            if (__Pyx_CyFunction_init_defaults(op) < 0) return NULL;
+            if (unlikely(__Pyx_CyFunction_init_defaults(op) < 0)) return NULL;
             result = op->defaults_kwdict;
         } else {
             result = Py_None;
@@ -72577,24 +93702,33 @@ __Pyx_CyFunction_get_kwdefaults(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *
     Py_INCREF(result);
     return result;
 }
+static PyObject *
+__Pyx_CyFunction_get_kwdefaults(__pyx_CyFunctionObject *op, void *context) {
+    PyObject* result;
+    CYTHON_UNUSED_VAR(context);
+    __Pyx_BEGIN_CRITICAL_SECTION(op);
+    result = __Pyx_CyFunction_get_kwdefaults_locked(op);
+    __Pyx_END_CRITICAL_SECTION();
+    return result;
+}
 static int
-__Pyx_CyFunction_set_annotations(__pyx_CyFunctionObject *op, PyObject* value, CYTHON_UNUSED void *context) {
-    PyObject* tmp;
+__Pyx_CyFunction_set_annotations(__pyx_CyFunctionObject *op, PyObject* value, void *context) {
+    CYTHON_UNUSED_VAR(context);
     if (!value || value == Py_None) {
         value = NULL;
-    } else if (!PyDict_Check(value)) {
+    } else if (unlikely(!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);
+    __Pyx_BEGIN_CRITICAL_SECTION(op);
+    __Pyx_Py_XDECREF_SET(op->func_annotations, value);
+    __Pyx_END_CRITICAL_SECTION();
     return 0;
 }
 static PyObject *
-__Pyx_CyFunction_get_annotations(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *context) {
+__Pyx_CyFunction_get_annotations_locked(__pyx_CyFunctionObject *op) {
     PyObject* result = op->func_annotations;
     if (unlikely(!result)) {
         result = PyDict_New();
@@ -72604,104 +93738,269 @@ __Pyx_CyFunction_get_annotations(__pyx_CyFunctionObject *op, CYTHON_UNUSED void
     Py_INCREF(result);
     return result;
 }
+static PyObject *
+__Pyx_CyFunction_get_annotations(__pyx_CyFunctionObject *op, void *context) {
+    PyObject *result;
+    CYTHON_UNUSED_VAR(context);
+    __Pyx_BEGIN_CRITICAL_SECTION(op);
+    result = __Pyx_CyFunction_get_annotations_locked(op);
+    __Pyx_END_CRITICAL_SECTION();
+    return result;
+}
+static PyObject *
+__Pyx_CyFunction_get_is_coroutine_value(__pyx_CyFunctionObject *op) {
+    int is_coroutine = op->flags & __Pyx_CYFUNCTION_COROUTINE;
+    if (is_coroutine) {
+        PyObject *is_coroutine_value, *module, *fromlist, *marker = __pyx_mstate_global->__pyx_n_u_is_coroutine;
+        fromlist = PyList_New(1);
+        if (unlikely(!fromlist)) return NULL;
+        Py_INCREF(marker);
+#if CYTHON_ASSUME_SAFE_MACROS
+        PyList_SET_ITEM(fromlist, 0, marker);
+#else
+        if (unlikely(PyList_SetItem(fromlist, 0, marker) < 0)) {
+            Py_DECREF(marker);
+            Py_DECREF(fromlist);
+            return NULL;
+        }
+#endif
+        module = PyImport_ImportModuleLevelObject(__pyx_mstate_global->__pyx_n_u_asyncio_coroutines, NULL, NULL, fromlist, 0);
+        Py_DECREF(fromlist);
+        if (unlikely(!module)) goto ignore;
+        is_coroutine_value = __Pyx_PyObject_GetAttrStr(module, marker);
+        Py_DECREF(module);
+        if (likely(is_coroutine_value)) {
+            return is_coroutine_value;
+        }
+ignore:
+        PyErr_Clear();
+    }
+    return __Pyx_PyBool_FromLong(is_coroutine);
+}
+static PyObject *
+__Pyx_CyFunction_get_is_coroutine(__pyx_CyFunctionObject *op, void *context) {
+    PyObject *result;
+    CYTHON_UNUSED_VAR(context);
+    if (op->func_is_coroutine) {
+        return __Pyx_NewRef(op->func_is_coroutine);
+    }
+    result = __Pyx_CyFunction_get_is_coroutine_value(op);
+    if (unlikely(!result))
+        return NULL;
+    __Pyx_BEGIN_CRITICAL_SECTION(op);
+    if (op->func_is_coroutine) {
+        Py_DECREF(result);
+        result = __Pyx_NewRef(op->func_is_coroutine);
+    } else {
+        op->func_is_coroutine = __Pyx_NewRef(result);
+    }
+    __Pyx_END_CRITICAL_SECTION();
+    return result;
+}
+static void __Pyx_CyFunction_raise_argument_count_error(__pyx_CyFunctionObject *func, const char* message, Py_ssize_t size) {
+#if CYTHON_COMPILING_IN_LIMITED_API
+    PyObject *py_name = __Pyx_CyFunction_get_name(func, NULL);
+    if (!py_name) return;
+    PyErr_Format(PyExc_TypeError,
+        "%.200S() %s (%" CYTHON_FORMAT_SSIZE_T "d given)",
+        py_name, message, size);
+    Py_DECREF(py_name);
+#else
+    const char* name = ((PyCFunctionObject*)func)->m_ml->ml_name;
+    PyErr_Format(PyExc_TypeError,
+        "%.200s() %s (%" CYTHON_FORMAT_SSIZE_T "d given)",
+        name, message, size);
+#endif
+}
+static void __Pyx_CyFunction_raise_type_error(__pyx_CyFunctionObject *func, const char* message) {
+#if CYTHON_COMPILING_IN_LIMITED_API
+    PyObject *py_name = __Pyx_CyFunction_get_name(func, NULL);
+    if (!py_name) return;
+    PyErr_Format(PyExc_TypeError,
+        "%.200S() %s",
+        py_name, message);
+    Py_DECREF(py_name);
+#else
+    const char* name = ((PyCFunctionObject*)func)->m_ml->ml_name;
+    PyErr_Format(PyExc_TypeError,
+        "%.200s() %s",
+        name, message);
+#endif
+}
+#if CYTHON_COMPILING_IN_LIMITED_API
+static PyObject *
+__Pyx_CyFunction_get_module(__pyx_CyFunctionObject *op, void *context) {
+    CYTHON_UNUSED_VAR(context);
+    return PyObject_GetAttrString(op->func, "__module__");
+}
+static int
+__Pyx_CyFunction_set_module(__pyx_CyFunctionObject *op, PyObject* value, void *context) {
+    CYTHON_UNUSED_VAR(context);
+    return PyObject_SetAttrString(op->func, "__module__", value);
+}
+#endif
 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},
+    {"func_doc", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0},
+    {"__doc__",  (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0},
+    {"func_name", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0},
+    {"__name__", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0},
+    {"__qualname__", (getter)__Pyx_CyFunction_get_qualname, (setter)__Pyx_CyFunction_set_qualname, 0, 0},
+    {"func_dict", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0},
+    {"__dict__", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0},
+    {"func_globals", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0},
+    {"__globals__", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0},
+    {"func_closure", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0},
+    {"__closure__", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0},
+    {"func_code", (getter)__Pyx_CyFunction_get_code, 0, 0, 0},
+    {"__code__", (getter)__Pyx_CyFunction_get_code, 0, 0, 0},
+    {"func_defaults", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0},
+    {"__defaults__", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0},
+    {"__kwdefaults__", (getter)__Pyx_CyFunction_get_kwdefaults, (setter)__Pyx_CyFunction_set_kwdefaults, 0, 0},
+    {"__annotations__", (getter)__Pyx_CyFunction_get_annotations, (setter)__Pyx_CyFunction_set_annotations, 0, 0},
+    {"_is_coroutine", (getter)__Pyx_CyFunction_get_is_coroutine, 0, 0, 0},
+#if CYTHON_COMPILING_IN_LIMITED_API
+    {"__module__", (getter)__Pyx_CyFunction_get_module, (setter)__Pyx_CyFunction_set_module, 0, 0},
+#endif
     {0, 0, 0, 0, 0}
 };
 static PyMemberDef __pyx_CyFunction_members[] = {
-    {(char *) "__module__", T_OBJECT, offsetof(PyCFunctionObject, m_module), PY_WRITE_RESTRICTED, 0},
+#if !CYTHON_COMPILING_IN_LIMITED_API
+    {"__module__", T_OBJECT, offsetof(PyCFunctionObject, m_module), 0, 0},
+#endif
+    {"__dictoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_dict), READONLY, 0},
+#if CYTHON_METH_FASTCALL
+#if CYTHON_BACKPORT_VECTORCALL || CYTHON_COMPILING_IN_LIMITED_API
+    {"__vectorcalloffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_vectorcall), READONLY, 0},
+#else
+    {"__vectorcalloffset__", T_PYSSIZET, offsetof(PyCFunctionObject, vectorcall), READONLY, 0},
+#endif
+#if CYTHON_COMPILING_IN_LIMITED_API
+    {"__weaklistoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_weakreflist), READONLY, 0},
+#else
+    {"__weaklistoffset__", T_PYSSIZET, offsetof(PyCFunctionObject, m_weakreflist), READONLY, 0},
+#endif
+#endif
     {0, 0, 0,  0, 0}
 };
 static PyObject *
-__Pyx_CyFunction_reduce(__pyx_CyFunctionObject *m, CYTHON_UNUSED PyObject *args)
+__Pyx_CyFunction_reduce(__pyx_CyFunctionObject *m, 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
+    PyObject *result = NULL;
+    CYTHON_UNUSED_VAR(args);
+    __Pyx_BEGIN_CRITICAL_SECTION(m);
+    Py_INCREF(m->func_qualname);
+    result = m->func_qualname;
+    __Pyx_END_CRITICAL_SECTION();
+    return result;
 }
 static PyMethodDef __pyx_CyFunction_methods[] = {
     {"__reduce__", (PyCFunction)__Pyx_CyFunction_reduce, METH_VARARGS, 0},
     {0, 0, 0, 0}
 };
-#if PY_VERSION_HEX < 0x030500A0
+#if CYTHON_COMPILING_IN_LIMITED_API
 #define __Pyx_CyFunction_weakreflist(cyfunc) ((cyfunc)->func_weakreflist)
 #else
-#define __Pyx_CyFunction_weakreflist(cyfunc) ((cyfunc)->func.m_weakreflist)
+#define __Pyx_CyFunction_weakreflist(cyfunc) (((PyCFunctionObject*)cyfunc)->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)
+static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject *op, PyMethodDef *ml, int flags, PyObject* qualname,
+                                       PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) {
+#if !CYTHON_COMPILING_IN_LIMITED_API
+    PyCFunctionObject *cf = (PyCFunctionObject*) op;
+#endif
+    if (unlikely(op == NULL))
         return NULL;
+#if CYTHON_COMPILING_IN_LIMITED_API
+    op->func = PyCFunction_NewEx(ml, (PyObject*)op, module);
+    if (unlikely(!op->func)) return NULL;
+#endif
     op->flags = flags;
     __Pyx_CyFunction_weakreflist(op) = NULL;
-    op->func.m_ml = ml;
-    op->func.m_self = (PyObject *) op;
+#if !CYTHON_COMPILING_IN_LIMITED_API
+    cf->m_ml = ml;
+    cf->m_self = (PyObject *) op;
+#endif
     Py_XINCREF(closure);
     op->func_closure = closure;
+#if !CYTHON_COMPILING_IN_LIMITED_API
     Py_XINCREF(module);
-    op->func.m_module = module;
+    cf->m_module = module;
+#endif
     op->func_dict = NULL;
     op->func_name = NULL;
     Py_INCREF(qualname);
     op->func_qualname = qualname;
     op->func_doc = NULL;
+#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API
     op->func_classobj = NULL;
+#else
+    ((PyCMethodObject*)op)->mm_class = NULL;
+#endif
     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);
+    op->func_is_coroutine = NULL;
+#if CYTHON_METH_FASTCALL
+    switch (ml->ml_flags & (METH_VARARGS | METH_FASTCALL | METH_NOARGS | METH_O | METH_KEYWORDS | METH_METHOD)) {
+    case METH_NOARGS:
+        __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_NOARGS;
+        break;
+    case METH_O:
+        __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_O;
+        break;
+    case METH_METHOD | METH_FASTCALL | METH_KEYWORDS:
+        __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD;
+        break;
+    case METH_FASTCALL | METH_KEYWORDS:
+        __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS;
+        break;
+    case METH_VARARGS | METH_KEYWORDS:
+        __Pyx_CyFunction_func_vectorcall(op) = NULL;
+        break;
+    default:
+        PyErr_SetString(PyExc_SystemError, "Bad call flags for CyFunction");
+        Py_DECREF(op);
+        return NULL;
+    }
+#endif
     return (PyObject *) op;
 }
 static int
 __Pyx_CyFunction_clear(__pyx_CyFunctionObject *m)
 {
     Py_CLEAR(m->func_closure);
-    Py_CLEAR(m->func.m_module);
+#if CYTHON_COMPILING_IN_LIMITED_API
+    Py_CLEAR(m->func);
+#else
+    Py_CLEAR(((PyCFunctionObject*)m)->m_module);
+#endif
     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);
+#if !CYTHON_COMPILING_IN_LIMITED_API
+#if PY_VERSION_HEX < 0x030900B1
+    Py_CLEAR(__Pyx_CyFunction_GetClassObj(m));
+#else
+    {
+        PyObject *cls = (PyObject*) ((PyCMethodObject *) (m))->mm_class;
+        ((PyCMethodObject *) (m))->mm_class = NULL;
+        Py_XDECREF(cls);
+    }
+#endif
+#endif
     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;
-    }
+    Py_CLEAR(m->func_is_coroutine);
+    Py_CLEAR(m->defaults);
     return 0;
 }
 static void __Pyx__CyFunction_dealloc(__pyx_CyFunctionObject *m)
@@ -72709,7 +94008,7 @@ static void __Pyx__CyFunction_dealloc(__pyx_CyFunctionObject *m)
     if (__Pyx_CyFunction_weakreflist(m) != NULL)
         PyObject_ClearWeakRefs((PyObject *) m);
     __Pyx_CyFunction_clear(m);
-    PyObject_GC_Del(m);
+    __Pyx_PyHeapTypeObject_GC_Del(m);
 }
 static void __Pyx_CyFunction_dealloc(__pyx_CyFunctionObject *m)
 {
@@ -72718,83 +94017,93 @@ static void __Pyx_CyFunction_dealloc(__pyx_CyFunctionObject *m)
 }
 static int __Pyx_CyFunction_traverse(__pyx_CyFunctionObject *m, visitproc visit, void *arg)
 {
+    {
+        int e = __Pyx_call_type_traverse((PyObject*)m, 1, visit, arg);
+        if (e) return e;
+    }
     Py_VISIT(m->func_closure);
-    Py_VISIT(m->func.m_module);
+#if CYTHON_COMPILING_IN_LIMITED_API
+    Py_VISIT(m->func);
+#else
+    Py_VISIT(((PyCFunctionObject*)m)->m_module);
+#endif
     Py_VISIT(m->func_dict);
-    Py_VISIT(m->func_name);
-    Py_VISIT(m->func_qualname);
+    __Pyx_VISIT_CONST(m->func_name);
+    __Pyx_VISIT_CONST(m->func_qualname);
     Py_VISIT(m->func_doc);
     Py_VISIT(m->func_globals);
-    Py_VISIT(m->func_code);
-    Py_VISIT(m->func_classobj);
+    __Pyx_VISIT_CONST(m->func_code);
+#if !CYTHON_COMPILING_IN_LIMITED_API
+    Py_VISIT(__Pyx_CyFunction_GetClassObj(m));
+#endif
     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]);
-    }
+    Py_VISIT(m->func_is_coroutine);
+    Py_VISIT(m->defaults);
     return 0;
 }
-static PyObject *__Pyx_CyFunction_descr_get(PyObject *func, PyObject *obj, PyObject *type)
-{
-    __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func;
-    if (m->flags & __Pyx_CYFUNCTION_STATICMETHOD) {
-        Py_INCREF(func);
-        return func;
-    }
-    if (m->flags & __Pyx_CYFUNCTION_CLASSMETHOD) {
-        if (type == NULL)
-            type = (PyObject *)(Py_TYPE(obj));
-        return __Pyx_PyMethod_New(func, type, (PyObject *)(Py_TYPE(type)));
-    }
-    if (obj == Py_None)
-        obj = NULL;
-    return __Pyx_PyMethod_New(func, obj, type);
-}
 static PyObject*
 __Pyx_CyFunction_repr(__pyx_CyFunctionObject *op)
 {
-#if PY_MAJOR_VERSION >= 3
-    return PyUnicode_FromFormat("<cyfunction %U at %p>",
+    PyObject *repr;
+    __Pyx_BEGIN_CRITICAL_SECTION(op);
+    repr = PyUnicode_FromFormat("<cyfunction %U at %p>",
                                 op->func_qualname, (void *)op);
-#else
-    return PyString_FromFormat("<cyfunction %s at %p>",
-                               PyString_AsString(op->func_qualname), (void *)op);
-#endif
+    __Pyx_END_CRITICAL_SECTION();
+    return repr;
 }
 static PyObject * __Pyx_CyFunction_CallMethod(PyObject *func, PyObject *self, PyObject *arg, PyObject *kw) {
+#if CYTHON_COMPILING_IN_LIMITED_API
+    PyObject *f = ((__pyx_CyFunctionObject*)func)->func;
+    PyCFunction meth;
+    int flags;
+    meth = PyCFunction_GetFunction(f);
+    if (unlikely(!meth)) return NULL;
+    flags = PyCFunction_GetFlags(f);
+    if (unlikely(flags < 0)) return NULL;
+#else
     PyCFunctionObject* f = (PyCFunctionObject*)func;
     PyCFunction meth = f->m_ml->ml_meth;
+    int flags = f->m_ml->ml_flags;
+#endif
     Py_ssize_t size;
-    switch (f->m_ml->ml_flags & (METH_VARARGS | METH_KEYWORDS | METH_NOARGS | METH_O)) {
+    switch (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)(void*)meth)(self, arg, kw);
+        return (*(PyCFunctionWithKeywords)(void(*)(void))meth)(self, arg, kw);
     case METH_NOARGS:
         if (likely(kw == NULL || PyDict_Size(kw) == 0)) {
+#if CYTHON_ASSUME_SAFE_SIZE
             size = PyTuple_GET_SIZE(arg);
+#else
+            size = PyTuple_Size(arg);
+            if (unlikely(size < 0)) return NULL;
+#endif
             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);
+            __Pyx_CyFunction_raise_argument_count_error(
+                (__pyx_CyFunctionObject*)func,
+                "takes no arguments", size);
             return NULL;
         }
         break;
     case METH_O:
         if (likely(kw == NULL || PyDict_Size(kw) == 0)) {
+#if CYTHON_ASSUME_SAFE_SIZE
             size = PyTuple_GET_SIZE(arg);
+#else
+            size = PyTuple_Size(arg);
+            if (unlikely(size < 0)) return NULL;
+#endif
             if (likely(size == 1)) {
                 PyObject *result, *arg0;
                 #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
                 arg0 = PyTuple_GET_ITEM(arg, 0);
                 #else
-                arg0 = PySequence_ITEM(arg, 0); if (unlikely(!arg0)) return NULL;
+                arg0 = __Pyx_PySequence_ITEM(arg, 0); if (unlikely(!arg0)) return NULL;
                 #endif
                 result = (*meth)(self, arg0);
                 #if !(CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS)
@@ -72802,39 +94111,64 @@ static PyObject * __Pyx_CyFunction_CallMethod(PyObject *func, PyObject *self, Py
                 #endif
                 return result;
             }
-            PyErr_Format(PyExc_TypeError,
-                "%.200s() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)",
-                f->m_ml->ml_name, size);
+            __Pyx_CyFunction_raise_argument_count_error(
+                (__pyx_CyFunctionObject*)func,
+                "takes exactly one argument", size);
             return NULL;
         }
         break;
     default:
-        PyErr_SetString(PyExc_SystemError, "Bad call flags in "
-                        "__Pyx_CyFunction_Call. METH_OLDARGS is no "
-                        "longer supported!");
+        PyErr_SetString(PyExc_SystemError, "Bad call flags for CyFunction");
         return NULL;
     }
-    PyErr_Format(PyExc_TypeError, "%.200s() takes no keyword arguments",
-                 f->m_ml->ml_name);
+    __Pyx_CyFunction_raise_type_error(
+        (__pyx_CyFunctionObject*)func, "takes no keyword arguments");
     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);
+    PyObject *self, *result;
+#if CYTHON_COMPILING_IN_LIMITED_API
+    self = PyCFunction_GetSelf(((__pyx_CyFunctionObject*)func)->func);
+    if (unlikely(!self) && PyErr_Occurred()) return NULL;
+#else
+    self = ((PyCFunctionObject*)func)->m_self;
+#endif
+    result = __Pyx_CyFunction_CallMethod(func, self, arg, kw);
+    return result;
 }
 static PyObject *__Pyx_CyFunction_CallAsMethod(PyObject *func, PyObject *args, PyObject *kw) {
     PyObject *result;
     __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *) func;
+#if CYTHON_METH_FASTCALL && (CYTHON_VECTORCALL || CYTHON_BACKPORT_VECTORCALL)
+     __pyx_vectorcallfunc vc = __Pyx_CyFunction_func_vectorcall(cyfunc);
+    if (vc) {
+#if CYTHON_ASSUME_SAFE_MACROS && CYTHON_ASSUME_SAFE_SIZE
+        return __Pyx_PyVectorcall_FastCallDict(func, vc, &PyTuple_GET_ITEM(args, 0), (size_t)PyTuple_GET_SIZE(args), kw);
+#else
+        (void) &__Pyx_PyVectorcall_FastCallDict;
+        return PyVectorcall_Call(func, args, kw);
+#endif
+    }
+#endif
     if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) {
         Py_ssize_t argc;
         PyObject *new_args;
         PyObject *self;
+#if CYTHON_ASSUME_SAFE_SIZE
         argc = PyTuple_GET_SIZE(args);
+#else
+        argc = PyTuple_Size(args);
+        if (unlikely(argc < 0)) return NULL;
+#endif
         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);
+            PyErr_Format(PyExc_TypeError,
+                         "unbound method %.200S() needs an argument",
+                         cyfunc->func_qualname);
             return NULL;
         }
         result = __Pyx_CyFunction_CallMethod(func, self, new_args, kw);
@@ -72844,80 +94178,219 @@ static PyObject *__Pyx_CyFunction_CallAsMethod(PyObject *func, PyObject *args, P
     }
     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,
+#if CYTHON_METH_FASTCALL && (CYTHON_VECTORCALL || CYTHON_BACKPORT_VECTORCALL)
+static CYTHON_INLINE int __Pyx_CyFunction_Vectorcall_CheckArgs(__pyx_CyFunctionObject *cyfunc, Py_ssize_t nargs, PyObject *kwnames)
+{
+    int ret = 0;
+    if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) {
+        if (unlikely(nargs < 1)) {
+            __Pyx_CyFunction_raise_type_error(
+                cyfunc, "needs an argument");
+            return -1;
+        }
+        ret = 1;
+    }
+    if (unlikely(kwnames) && unlikely(__Pyx_PyTuple_GET_SIZE(kwnames))) {
+        __Pyx_CyFunction_raise_type_error(
+            cyfunc, "takes no keyword arguments");
+        return -1;
+    }
+    return ret;
+}
+static PyObject * __Pyx_CyFunction_Vectorcall_NOARGS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames)
+{
+    __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func;
+#if CYTHON_BACKPORT_VECTORCALL
+    Py_ssize_t nargs = (Py_ssize_t)nargsf;
 #else
-    0,
+    Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
 #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),
+    PyObject *self;
+#if CYTHON_COMPILING_IN_LIMITED_API
+    PyCFunction meth = PyCFunction_GetFunction(cyfunc->func);
+    if (unlikely(!meth)) return NULL;
 #else
-    offsetof(PyCFunctionObject, m_weakreflist),
+    PyCFunction meth = ((PyCFunctionObject*)cyfunc)->m_ml->ml_meth;
 #endif
+    switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, kwnames)) {
+    case 1:
+        self = args[0];
+        args += 1;
+        nargs -= 1;
+        break;
+    case 0:
+#if CYTHON_COMPILING_IN_LIMITED_API
+        self = PyCFunction_GetSelf(((__pyx_CyFunctionObject*)cyfunc)->func);
+        if (unlikely(!self) && PyErr_Occurred()) return NULL;
+#else
+        self = ((PyCFunctionObject*)cyfunc)->m_self;
+#endif
+        break;
+    default:
+        return NULL;
+    }
+    if (unlikely(nargs != 0)) {
+        __Pyx_CyFunction_raise_argument_count_error(
+            cyfunc, "takes no arguments", nargs);
+        return NULL;
+    }
+    return meth(self, NULL);
+}
+static PyObject * __Pyx_CyFunction_Vectorcall_O(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames)
+{
+    __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func;
+#if CYTHON_BACKPORT_VECTORCALL
+    Py_ssize_t nargs = (Py_ssize_t)nargsf;
+#else
+    Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
+#endif
+    PyObject *self;
+#if CYTHON_COMPILING_IN_LIMITED_API
+    PyCFunction meth = PyCFunction_GetFunction(cyfunc->func);
+    if (unlikely(!meth)) return NULL;
+#else
+    PyCFunction meth = ((PyCFunctionObject*)cyfunc)->m_ml->ml_meth;
+#endif
+    switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, kwnames)) {
+    case 1:
+        self = args[0];
+        args += 1;
+        nargs -= 1;
+        break;
+    case 0:
+#if CYTHON_COMPILING_IN_LIMITED_API
+        self = PyCFunction_GetSelf(((__pyx_CyFunctionObject*)cyfunc)->func);
+        if (unlikely(!self) && PyErr_Occurred()) return NULL;
+#else
+        self = ((PyCFunctionObject*)cyfunc)->m_self;
+#endif
+        break;
+    default:
+        return NULL;
+    }
+    if (unlikely(nargs != 1)) {
+        __Pyx_CyFunction_raise_argument_count_error(
+            cyfunc, "takes exactly one argument", nargs);
+        return NULL;
+    }
+    return meth(self, args[0]);
+}
+static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames)
+{
+    __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func;
+#if CYTHON_BACKPORT_VECTORCALL
+    Py_ssize_t nargs = (Py_ssize_t)nargsf;
+#else
+    Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
+#endif
+    PyObject *self;
+#if CYTHON_COMPILING_IN_LIMITED_API
+    PyCFunction meth = PyCFunction_GetFunction(cyfunc->func);
+    if (unlikely(!meth)) return NULL;
+#else
+    PyCFunction meth = ((PyCFunctionObject*)cyfunc)->m_ml->ml_meth;
+#endif
+    switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, NULL)) {
+    case 1:
+        self = args[0];
+        args += 1;
+        nargs -= 1;
+        break;
+    case 0:
+#if CYTHON_COMPILING_IN_LIMITED_API
+        self = PyCFunction_GetSelf(((__pyx_CyFunctionObject*)cyfunc)->func);
+        if (unlikely(!self) && PyErr_Occurred()) return NULL;
+#else
+        self = ((PyCFunctionObject*)cyfunc)->m_self;
+#endif
+        break;
+    default:
+        return NULL;
+    }
+    return ((__Pyx_PyCFunctionFastWithKeywords)(void(*)(void))meth)(self, args, nargs, kwnames);
+}
+static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames)
+{
+    __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func;
+    PyTypeObject *cls = (PyTypeObject *) __Pyx_CyFunction_GetClassObj(cyfunc);
+#if CYTHON_BACKPORT_VECTORCALL
+    Py_ssize_t nargs = (Py_ssize_t)nargsf;
+#else
+    Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
+#endif
+    PyObject *self;
+#if CYTHON_COMPILING_IN_LIMITED_API
+    PyCFunction meth = PyCFunction_GetFunction(cyfunc->func);
+    if (unlikely(!meth)) return NULL;
+#else
+    PyCFunction meth = ((PyCFunctionObject*)cyfunc)->m_ml->ml_meth;
+#endif
+    switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, NULL)) {
+    case 1:
+        self = args[0];
+        args += 1;
+        nargs -= 1;
+        break;
+    case 0:
+#if CYTHON_COMPILING_IN_LIMITED_API
+        self = PyCFunction_GetSelf(((__pyx_CyFunctionObject*)cyfunc)->func);
+        if (unlikely(!self) && PyErr_Occurred()) return NULL;
+#else
+        self = ((PyCFunctionObject*)cyfunc)->m_self;
+#endif
+        break;
+    default:
+        return NULL;
+    }
+    return ((__Pyx_PyCMethod)(void(*)(void))meth)(self, cls, args, (size_t)nargs, kwnames);
+}
+#endif
+static PyType_Slot __pyx_CyFunctionType_slots[] = {
+    {Py_tp_dealloc, (void *)__Pyx_CyFunction_dealloc},
+    {Py_tp_repr, (void *)__Pyx_CyFunction_repr},
+    {Py_tp_call, (void *)__Pyx_CyFunction_CallAsMethod},
+    {Py_tp_traverse, (void *)__Pyx_CyFunction_traverse},
+    {Py_tp_clear, (void *)__Pyx_CyFunction_clear},
+    {Py_tp_methods, (void *)__pyx_CyFunction_methods},
+    {Py_tp_members, (void *)__pyx_CyFunction_members},
+    {Py_tp_getset, (void *)__pyx_CyFunction_getsets},
+    {Py_tp_descr_get, (void *)__Pyx_PyMethod_New},
+    {0, 0},
+};
+static PyType_Spec __pyx_CyFunctionType_spec = {
+    __PYX_TYPE_MODULE_PREFIX "cython_function_or_method",
+    sizeof(__pyx_CyFunctionObject),
     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,
+#ifdef Py_TPFLAGS_METHOD_DESCRIPTOR
+    Py_TPFLAGS_METHOD_DESCRIPTOR |
+#endif
+#if CYTHON_METH_FASTCALL
+#if defined(Py_TPFLAGS_HAVE_VECTORCALL)
+    Py_TPFLAGS_HAVE_VECTORCALL |
+#elif defined(_Py_TPFLAGS_HAVE_VECTORCALL)
+    _Py_TPFLAGS_HAVE_VECTORCALL |
 #endif
+#endif // CYTHON_METH_FASTCALL
+#if PY_VERSION_HEX >= 0x030A0000
+    Py_TPFLAGS_IMMUTABLETYPE |
+#endif
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE,
+    __pyx_CyFunctionType_slots
 };
-static int __pyx_CyFunction_init(void) {
-    __pyx_CyFunctionType = __Pyx_FetchCommonType(&__pyx_CyFunctionType_type);
-    if (unlikely(__pyx_CyFunctionType == NULL)) {
+static int __pyx_CyFunction_init(PyObject *module) {
+    __pyx_mstatetype *mstate = __Pyx_PyModule_GetState(module);
+    mstate->__pyx_CyFunctionType = __Pyx_FetchCommonTypeFromSpec(
+        mstate->__pyx_CommonTypesMetaclassType, module, &__pyx_CyFunctionType_spec, NULL);
+    if (unlikely(mstate->__pyx_CyFunctionType == NULL)) {
         return -1;
     }
     return 0;
 }
-static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *func, size_t size, int pyobjects) {
+static CYTHON_INLINE PyObject *__Pyx_CyFunction_InitDefaults(PyObject *func, PyTypeObject *defaults_type) {
     __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func;
-    m->defaults = PyObject_Malloc(size);
+    m->defaults = PyObject_CallObject((PyObject*)defaults_type, NULL); // _PyObject_New(defaults_type);
     if (unlikely(!m->defaults))
-        return PyErr_NoMemory();
-    memset(m->defaults, 0, size);
-    m->defaults_pyobjects = pyobjects;
+        return NULL;
     return m->defaults;
 }
 static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *func, PyObject *tuple) {
@@ -72936,25 +94409,203 @@ static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *func, Py
     Py_INCREF(dict);
 }
 
+/* CythonFunction */
+static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml, int flags, PyObject* qualname,
+                                      PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) {
+    PyObject *op = __Pyx_CyFunction_Init(
+        PyObject_GC_New(__pyx_CyFunctionObject, __pyx_mstate_global->__pyx_CyFunctionType),
+        ml, flags, qualname, closure, module, globals, code
+    );
+    if (likely(op)) {
+        PyObject_GC_Track(op);
+    }
+    return op;
+}
+
+/* Py3UpdateBases */
+static PyObject*
+__Pyx_PEP560_update_bases(PyObject *bases)
+{
+    Py_ssize_t i, j, size_bases;
+    PyObject *base = NULL, *meth, *new_base, *result, *new_bases = NULL;
+#if CYTHON_ASSUME_SAFE_SIZE
+    size_bases = PyTuple_GET_SIZE(bases);
+#else
+    size_bases = PyTuple_Size(bases);
+    if (size_bases < 0) return NULL;
+#endif
+    for (i = 0; i < size_bases; i++) {
+#if CYTHON_AVOID_BORROWED_REFS
+        Py_CLEAR(base);
+#endif
+#if CYTHON_ASSUME_SAFE_MACROS
+        base = PyTuple_GET_ITEM(bases, i);
+#else
+        base = PyTuple_GetItem(bases, i);
+        if (!base) goto error;
+#endif
+#if CYTHON_AVOID_BORROWED_REFS
+        Py_INCREF(base);
+#endif
+        if (PyType_Check(base)) {
+            if (new_bases) {
+                if (PyList_Append(new_bases, base) < 0) {
+                    goto error;
+                }
+            }
+            continue;
+        }
+        meth = __Pyx_PyObject_GetAttrStrNoError(base, __pyx_mstate_global->__pyx_n_u_mro_entries);
+        if (!meth && PyErr_Occurred()) {
+            goto error;
+        }
+        if (!meth) {
+            if (new_bases) {
+                if (PyList_Append(new_bases, base) < 0) {
+                    goto error;
+                }
+            }
+            continue;
+        }
+        new_base = __Pyx_PyObject_CallOneArg(meth, bases);
+        Py_DECREF(meth);
+        if (!new_base) {
+            goto error;
+        }
+        if (!PyTuple_Check(new_base)) {
+            PyErr_SetString(PyExc_TypeError,
+                            "__mro_entries__ must return a tuple");
+            Py_DECREF(new_base);
+            goto error;
+        }
+        if (!new_bases) {
+            if (!(new_bases = PyList_New(i))) {
+                goto error;
+            }
+            for (j = 0; j < i; j++) {
+                PyObject *base_from_list;
+#if CYTHON_ASSUME_SAFE_MACROS
+                base_from_list = PyTuple_GET_ITEM(bases, j);
+                PyList_SET_ITEM(new_bases, j, base_from_list);
+                Py_INCREF(base_from_list);
+#else
+                base_from_list = PyTuple_GetItem(bases, j);
+                if (!base_from_list) goto error;
+                Py_INCREF(base_from_list);
+                if (PyList_SetItem(new_bases, j, base_from_list) < 0) goto error;
+#endif
+            }
+        }
+#if CYTHON_ASSUME_SAFE_SIZE
+        j = PyList_GET_SIZE(new_bases);
+#else
+        j = PyList_Size(new_bases);
+        if (j < 0) goto error;
+#endif
+        if (PyList_SetSlice(new_bases, j, j, new_base) < 0) {
+            goto error;
+        }
+        Py_DECREF(new_base);
+    }
+    if (!new_bases) {
+        Py_INCREF(bases);
+        return bases;
+    }
+    result = PyList_AsTuple(new_bases);
+    Py_DECREF(new_bases);
+#if CYTHON_AVOID_BORROWED_REFS
+    Py_XDECREF(base);
+#endif
+    return result;
+error:
+    Py_XDECREF(new_bases);
+#if CYTHON_AVOID_BORROWED_REFS
+    Py_XDECREF(base);
+#endif
+    return NULL;
+}
+
+/* CalculateMetaclass */
+static PyObject *__Pyx_CalculateMetaclass(PyTypeObject *metaclass, PyObject *bases) {
+    Py_ssize_t i, nbases;
+#if CYTHON_ASSUME_SAFE_SIZE
+    nbases = PyTuple_GET_SIZE(bases);
+#else
+    nbases = PyTuple_Size(bases);
+    if (nbases < 0) return NULL;
+#endif
+    for (i=0; i < nbases; i++) {
+        PyTypeObject *tmptype;
+#if CYTHON_ASSUME_SAFE_MACROS
+        PyObject *tmp = PyTuple_GET_ITEM(bases, i);
+#else
+        PyObject *tmp = PyTuple_GetItem(bases, i);
+        if (!tmp) return NULL;
+#endif
+        tmptype = Py_TYPE(tmp);
+        if (!metaclass) {
+            metaclass = tmptype;
+            continue;
+        }
+        if (PyType_IsSubtype(metaclass, tmptype))
+            continue;
+        if (PyType_IsSubtype(tmptype, metaclass)) {
+            metaclass = tmptype;
+            continue;
+        }
+        PyErr_SetString(PyExc_TypeError,
+                        "metaclass conflict: "
+                        "the metaclass of a derived class "
+                        "must be a (non-strict) subclass "
+                        "of the metaclasses of all its bases");
+        return NULL;
+    }
+    if (!metaclass) {
+        metaclass = &PyType_Type;
+    }
+    Py_INCREF((PyObject*) metaclass);
+    return (PyObject*) metaclass;
+}
+
+/* PyObjectCall2Args */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2) {
+    PyObject *args[3] = {NULL, arg1, arg2};
+    return __Pyx_PyObject_FastCall(function, args+1, 2 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET);
+}
+
+/* PyObjectLookupSpecial */
+#if CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS
+static CYTHON_INLINE PyObject* __Pyx__PyObject_LookupSpecial(PyObject* obj, PyObject* attr_name, int with_error) {
+    PyObject *res;
+    PyTypeObject *tp = Py_TYPE(obj);
+    res = _PyType_Lookup(tp, attr_name);
+    if (likely(res)) {
+        descrgetfunc f = Py_TYPE(res)->tp_descr_get;
+        if (!f) {
+            Py_INCREF(res);
+        } else {
+            res = f(res, obj, (PyObject *)tp);
+        }
+    } else if (with_error) {
+        PyErr_SetObject(PyExc_AttributeError, attr_name);
+    }
+    return res;
+}
+#endif
+
 /* Py3ClassCreate */
 static PyObject *__Pyx_Py3MetaclassPrepare(PyObject *metaclass, PyObject *bases, PyObject *name,
                                            PyObject *qualname, PyObject *mkw, PyObject *modname, PyObject *doc) {
     PyObject *ns;
     if (metaclass) {
-        PyObject *prep = __Pyx_PyObject_GetAttrStr(metaclass, __pyx_n_s_prepare);
+        PyObject *prep = __Pyx_PyObject_GetAttrStrNoError(metaclass, __pyx_mstate_global->__pyx_n_u_prepare);
         if (prep) {
-            PyObject *pargs = PyTuple_Pack(2, name, bases);
-            if (unlikely(!pargs)) {
-                Py_DECREF(prep);
-                return NULL;
-            }
-            ns = PyObject_Call(prep, pargs, mkw);
+            PyObject *pargs[3] = {NULL, name, bases};
+            ns = __Pyx_PyObject_FastCallDict(prep, pargs+1, 2 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET, mkw);
             Py_DECREF(prep);
-            Py_DECREF(pargs);
         } else {
-            if (unlikely(!PyErr_ExceptionMatches(PyExc_AttributeError)))
+            if (unlikely(PyErr_Occurred()))
                 return NULL;
-            PyErr_Clear();
             ns = PyDict_New();
         }
     } else {
@@ -72962,9 +94613,9 @@ static PyObject *__Pyx_Py3MetaclassPrepare(PyObject *metaclass, PyObject *bases,
     }
     if (unlikely(!ns))
         return NULL;
-    if (unlikely(PyObject_SetItem(ns, __pyx_n_s_module, modname) < 0)) goto bad;
-    if (unlikely(PyObject_SetItem(ns, __pyx_n_s_qualname, qualname) < 0)) goto bad;
-    if (unlikely(doc && PyObject_SetItem(ns, __pyx_n_s_doc, doc) < 0)) goto bad;
+    if (unlikely(PyObject_SetItem(ns, __pyx_mstate_global->__pyx_n_u_module, modname) < 0)) goto bad;
+    if (unlikely(PyObject_SetItem(ns, __pyx_mstate_global->__pyx_n_u_qualname, qualname) < 0)) goto bad;
+    if (unlikely(doc && PyObject_SetItem(ns, __pyx_mstate_global->__pyx_n_u_doc, doc) < 0)) goto bad;
     return ns;
 bad:
     Py_DECREF(ns);
@@ -72973,10 +94624,11 @@ static PyObject *__Pyx_Py3MetaclassPrepare(PyObject *metaclass, PyObject *bases,
 static PyObject *__Pyx_Py3ClassCreate(PyObject *metaclass, PyObject *name, PyObject *bases,
                                       PyObject *dict, PyObject *mkw,
                                       int calculate_metaclass, int allow_py2_metaclass) {
-    PyObject *result, *margs;
+    PyObject *result;
     PyObject *owned_metaclass = NULL;
+    PyObject *margs[4] = {NULL, name, bases, dict};
     if (allow_py2_metaclass) {
-        owned_metaclass = PyObject_GetItem(dict, __pyx_n_s_metaclass);
+        owned_metaclass = PyObject_GetItem(dict, __pyx_mstate_global->__pyx_n_u_metaclass);
         if (owned_metaclass) {
             metaclass = owned_metaclass;
         } else if (likely(PyErr_ExceptionMatches(PyExc_KeyError))) {
@@ -72992,79 +94644,58 @@ static PyObject *__Pyx_Py3ClassCreate(PyObject *metaclass, PyObject *name, PyObj
             return NULL;
         owned_metaclass = metaclass;
     }
-    margs = PyTuple_Pack(3, name, bases, dict);
-    if (unlikely(!margs)) {
-        result = NULL;
-    } else {
-        result = PyObject_Call(metaclass, margs, mkw);
-        Py_DECREF(margs);
-    }
+    result = __Pyx_PyObject_FastCallDict(metaclass, margs+1, 3 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET, mkw);
     Py_XDECREF(owned_metaclass);
     return result;
 }
 
+/* ListPack */
+static PyObject *__Pyx_PyList_Pack(Py_ssize_t n, ...) {
+    va_list va;
+    PyObject *l = PyList_New(n);
+    va_start(va, n);
+    if (unlikely(!l)) goto end;
+    for (Py_ssize_t i=0; i<n; ++i) {
+        PyObject *arg = va_arg(va, PyObject*);
+        Py_INCREF(arg);
+        if (__Pyx_PyList_SET_ITEM(l, i, arg) != (0)) {
+            Py_CLEAR(l);
+            goto end;
+        }
+    }
+    end:
+    va_end(va);
+    return l;
+}
+
 /* 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_MAJOR_VERSION < 3
-    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;
+    PyObject *empty_list = 0;
     empty_dict = PyDict_New();
-    if (!empty_dict)
+    if (unlikely(!empty_dict))
         goto bad;
-    {
-        #if PY_MAJOR_VERSION >= 3
-        if (level == -1) {
-            if (strchr(__Pyx_MODULE_NAME, '.')) {
-                module = PyImport_ImportModuleLevelObject(
-                    name, global_dict, empty_dict, list, 1);
-                if (!module) {
-                    if (!PyErr_ExceptionMatches(PyExc_ImportError))
-                        goto bad;
-                    PyErr_Clear();
-                }
-            }
-            level = 0;
-        }
-        #endif
-        if (!module) {
-            #if PY_MAJOR_VERSION < 3
-            PyObject *py_level = PyInt_FromLong(level);
-            if (!py_level)
-                goto bad;
-            module = PyObject_CallFunctionObjArgs(py_import,
-                name, global_dict, empty_dict, list, py_level, (PyObject *)NULL);
-            Py_DECREF(py_level);
-            #else
+    if (level == -1) {
+        const char* package_sep = strchr(__Pyx_MODULE_NAME, '.');
+        if (package_sep != (0)) {
             module = PyImport_ImportModuleLevelObject(
-                name, global_dict, empty_dict, list, level);
-            #endif
+                name, __pyx_mstate_global->__pyx_d, empty_dict, from_list, 1);
+            if (unlikely(!module)) {
+                if (unlikely(!PyErr_ExceptionMatches(PyExc_ImportError)))
+                    goto bad;
+                PyErr_Clear();
+            }
         }
+        level = 0;
+    }
+    if (!module) {
+        module = PyImport_ImportModuleLevelObject(
+            name, __pyx_mstate_global->__pyx_d, empty_dict, from_list, level);
     }
 bad:
-    #if PY_MAJOR_VERSION < 3
-    Py_XDECREF(py_import);
-    #endif
-    Py_XDECREF(empty_list);
     Py_XDECREF(empty_dict);
+    Py_XDECREF(empty_list);
     return module;
 }
 
@@ -73072,40 +94703,243 @@ static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) {
 static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name) {
     PyObject* value = __Pyx_PyObject_GetAttrStr(module, name);
     if (unlikely(!value) && PyErr_ExceptionMatches(PyExc_AttributeError)) {
-        PyErr_Format(PyExc_ImportError,
-        #if PY_MAJOR_VERSION < 3
-            "cannot import name %.230s", PyString_AS_STRING(name));
+        const char* module_name_str = 0;
+        PyObject* module_name = 0;
+        PyObject* module_dot = 0;
+        PyObject* full_name = 0;
+        PyErr_Clear();
+        module_name_str = PyModule_GetName(module);
+        if (unlikely(!module_name_str)) { goto modbad; }
+        module_name = PyUnicode_FromString(module_name_str);
+        if (unlikely(!module_name)) { goto modbad; }
+        module_dot = PyUnicode_Concat(module_name, __pyx_mstate_global->__pyx_kp_u__14);
+        if (unlikely(!module_dot)) { goto modbad; }
+        full_name = PyUnicode_Concat(module_dot, name);
+        if (unlikely(!full_name)) { goto modbad; }
+        #if (CYTHON_COMPILING_IN_PYPY && PYPY_VERSION_NUM  < 0x07030400) ||\
+                CYTHON_COMPILING_IN_GRAAL
+        {
+            PyObject *modules = PyImport_GetModuleDict();
+            if (unlikely(!modules))
+                goto modbad;
+            value = PyObject_GetItem(modules, full_name);
+        }
         #else
-            "cannot import name %S", name);
+        value = PyImport_GetModule(full_name);
         #endif
+      modbad:
+        Py_XDECREF(full_name);
+        Py_XDECREF(module_dot);
+        Py_XDECREF(module_name);
+    }
+    if (unlikely(!value)) {
+        PyErr_Format(PyExc_ImportError, "cannot import name %S", name);
     }
     return value;
 }
 
+/* ImportDottedModule */
+static PyObject *__Pyx__ImportDottedModule_Error(PyObject *name, PyObject *parts_tuple, Py_ssize_t count) {
+    PyObject *partial_name = NULL, *slice = NULL, *sep = NULL;
+    Py_ssize_t size;
+    if (unlikely(PyErr_Occurred())) {
+        PyErr_Clear();
+    }
+#if CYTHON_ASSUME_SAFE_SIZE
+    size = PyTuple_GET_SIZE(parts_tuple);
+#else
+    size = PyTuple_Size(parts_tuple);
+    if (size < 0) goto bad;
+#endif
+    if (likely(size == count)) {
+        partial_name = name;
+    } else {
+        slice = PySequence_GetSlice(parts_tuple, 0, count);
+        if (unlikely(!slice))
+            goto bad;
+        sep = PyUnicode_FromStringAndSize(".", 1);
+        if (unlikely(!sep))
+            goto bad;
+        partial_name = PyUnicode_Join(sep, slice);
+    }
+    PyErr_Format(
+        PyExc_ModuleNotFoundError,
+        "No module named '%U'", partial_name);
+bad:
+    Py_XDECREF(sep);
+    Py_XDECREF(slice);
+    Py_XDECREF(partial_name);
+    return NULL;
+}
+static PyObject *__Pyx__ImportDottedModule_Lookup(PyObject *name) {
+    PyObject *imported_module;
+#if (CYTHON_COMPILING_IN_PYPY && PYPY_VERSION_NUM  < 0x07030400) ||\
+        CYTHON_COMPILING_IN_GRAAL
+    PyObject *modules = PyImport_GetModuleDict();
+    if (unlikely(!modules))
+        return NULL;
+    imported_module = __Pyx_PyDict_GetItemStr(modules, name);
+    Py_XINCREF(imported_module);
+#else
+    imported_module = PyImport_GetModule(name);
+#endif
+    return imported_module;
+}
+static PyObject *__Pyx_ImportDottedModule_WalkParts(PyObject *module, PyObject *name, PyObject *parts_tuple) {
+    Py_ssize_t i, nparts;
+#if CYTHON_ASSUME_SAFE_SIZE
+    nparts = PyTuple_GET_SIZE(parts_tuple);
+#else
+    nparts = PyTuple_Size(parts_tuple);
+    if (nparts < 0) return NULL;
+#endif
+    for (i=1; i < nparts && module; i++) {
+        PyObject *part, *submodule;
+#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+        part = PyTuple_GET_ITEM(parts_tuple, i);
+#else
+        part = __Pyx_PySequence_ITEM(parts_tuple, i);
+        if (!part) return NULL;
+#endif
+        submodule = __Pyx_PyObject_GetAttrStrNoError(module, part);
+#if !(CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS)
+        Py_DECREF(part);
+#endif
+        Py_DECREF(module);
+        module = submodule;
+    }
+    if (unlikely(!module)) {
+        return __Pyx__ImportDottedModule_Error(name, parts_tuple, i);
+    }
+    return module;
+}
+static PyObject *__Pyx__ImportDottedModule(PyObject *name, PyObject *parts_tuple) {
+    PyObject *imported_module;
+    PyObject *module = __Pyx_Import(name, NULL, 0);
+    if (!parts_tuple || unlikely(!module))
+        return module;
+    imported_module = __Pyx__ImportDottedModule_Lookup(name);
+    if (likely(imported_module)) {
+        Py_DECREF(module);
+        return imported_module;
+    }
+    PyErr_Clear();
+    return __Pyx_ImportDottedModule_WalkParts(module, name, parts_tuple);
+}
+static PyObject *__Pyx_ImportDottedModule(PyObject *name, PyObject *parts_tuple) {
+#if CYTHON_COMPILING_IN_CPYTHON
+    PyObject *module = __Pyx__ImportDottedModule_Lookup(name);
+    if (likely(module)) {
+        PyObject *spec = __Pyx_PyObject_GetAttrStrNoError(module, __pyx_mstate_global->__pyx_n_u_spec);
+        if (likely(spec)) {
+            PyObject *unsafe = __Pyx_PyObject_GetAttrStrNoError(spec, __pyx_mstate_global->__pyx_n_u_initializing);
+            if (likely(!unsafe || !__Pyx_PyObject_IsTrue(unsafe))) {
+                Py_DECREF(spec);
+                spec = NULL;
+            }
+            Py_XDECREF(unsafe);
+        }
+        if (likely(!spec)) {
+            PyErr_Clear();
+            return module;
+        }
+        Py_DECREF(spec);
+        Py_DECREF(module);
+    } else if (PyErr_Occurred()) {
+        PyErr_Clear();
+    }
+#endif
+    return __Pyx__ImportDottedModule(name, parts_tuple);
+}
+
+/* ImportDottedModuleRelFirst */
+static PyObject *__Pyx_ImportDottedModuleRelFirst(PyObject *name, PyObject *parts_tuple) {
+    PyObject *module;
+    PyObject *from_list = NULL;
+    module = __Pyx_Import(name, from_list, -1);
+    Py_XDECREF(from_list);
+    if (module) {
+        if (parts_tuple) {
+            module = __Pyx_ImportDottedModule_WalkParts(module, name, parts_tuple);
+        }
+        return module;
+    }
+    if (unlikely(!PyErr_ExceptionMatches(PyExc_ImportError)))
+        return NULL;
+    PyErr_Clear();
+    return __Pyx_ImportDottedModule(name, parts_tuple);
+}
+
+/* PyObjectCallMethod1 */
+#if !(CYTHON_VECTORCALL && (__PYX_LIMITED_VERSION_HEX >= 0x030C0000 || (!CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x03090000)))
+static PyObject* __Pyx__PyObject_CallMethod1(PyObject* method, PyObject* arg) {
+    PyObject *result = __Pyx_PyObject_CallOneArg(method, arg);
+    Py_DECREF(method);
+    return result;
+}
+#endif
+static PyObject* __Pyx_PyObject_CallMethod1(PyObject* obj, PyObject* method_name, PyObject* arg) {
+#if CYTHON_VECTORCALL && (__PYX_LIMITED_VERSION_HEX >= 0x030C0000 || (!CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x03090000))
+    PyObject *args[2] = {obj, arg};
+    (void) __Pyx_PyObject_GetMethod;
+    (void) __Pyx_PyObject_CallOneArg;
+    (void) __Pyx_PyObject_Call2Args;
+    return PyObject_VectorcallMethod(method_name, args, 2 | PY_VECTORCALL_ARGUMENTS_OFFSET, NULL);
+#else
+    PyObject *method = NULL, *result;
+    int is_method = __Pyx_PyObject_GetMethod(obj, method_name, &method);
+    if (likely(is_method)) {
+        result = __Pyx_PyObject_Call2Args(method, obj, arg);
+        Py_DECREF(method);
+        return result;
+    }
+    if (unlikely(!method)) return NULL;
+    return __Pyx__PyObject_CallMethod1(method, arg);
+#endif
+}
+
+/* append */
+static CYTHON_INLINE int __Pyx_PyObject_Append(PyObject* L, PyObject* x) {
+    if (likely(PyList_CheckExact(L))) {
+        if (unlikely(__Pyx_PyList_Append(L, x) < 0)) return -1;
+    } else {
+        PyObject* retval = __Pyx_PyObject_CallMethod1(L, __pyx_mstate_global->__pyx_n_u_append, x);
+        if (unlikely(!retval))
+            return -1;
+        Py_DECREF(retval);
+    }
+    return 0;
+}
+
 /* CLineInTraceback */
-#ifndef CYTHON_CLINE_IN_TRACEBACK
+#if CYTHON_CLINE_IN_TRACEBACK && CYTHON_CLINE_IN_TRACEBACK_RUNTIME
 static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line) {
     PyObject *use_cline;
     PyObject *ptype, *pvalue, *ptraceback;
 #if CYTHON_COMPILING_IN_CPYTHON
     PyObject **cython_runtime_dict;
 #endif
-    if (unlikely(!__pyx_cython_runtime)) {
+    CYTHON_MAYBE_UNUSED_VAR(tstate);
+    if (unlikely(!__pyx_mstate_global->__pyx_cython_runtime)) {
         return c_line;
     }
     __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback);
 #if CYTHON_COMPILING_IN_CPYTHON
-    cython_runtime_dict = _PyObject_GetDictPtr(__pyx_cython_runtime);
+    cython_runtime_dict = _PyObject_GetDictPtr(__pyx_mstate_global->__pyx_cython_runtime);
     if (likely(cython_runtime_dict)) {
+        __Pyx_BEGIN_CRITICAL_SECTION(*cython_runtime_dict);
         __PYX_PY_DICT_LOOKUP_IF_MODIFIED(
             use_cline, *cython_runtime_dict,
-            __Pyx_PyDict_GetItemStr(*cython_runtime_dict, __pyx_n_s_cline_in_traceback))
+            __Pyx_PyDict_GetItemStr(*cython_runtime_dict, __pyx_mstate_global->__pyx_n_u_cline_in_traceback))
+        Py_XINCREF(use_cline);
+        __Pyx_END_CRITICAL_SECTION();
     } else
 #endif
     {
-      PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback);
+      PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStrNoError(__pyx_mstate_global->__pyx_cython_runtime, __pyx_mstate_global->__pyx_n_u_cline_in_traceback);
       if (use_cline_obj) {
         use_cline = PyObject_Not(use_cline_obj) ? Py_False : Py_True;
+        Py_INCREF(use_cline);
         Py_DECREF(use_cline_obj);
       } else {
         PyErr_Clear();
@@ -73114,11 +94948,12 @@ static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line) {
     }
     if (!use_cline) {
         c_line = 0;
-        PyObject_SetAttr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback, Py_False);
+        (void) PyObject_SetAttr(__pyx_mstate_global->__pyx_cython_runtime, __pyx_mstate_global->__pyx_n_u_cline_in_traceback, Py_False);
     }
     else if (use_cline == Py_False || (use_cline != Py_True && PyObject_Not(use_cline) != 0)) {
         c_line = 0;
     }
+    Py_XDECREF(use_cline);
     __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback);
     return c_line;
 }
@@ -73146,117 +94981,195 @@ static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int co
         return mid + 1;
     }
 }
-static PyCodeObject *__pyx_find_code_object(int code_line) {
-    PyCodeObject* code_object;
+static __Pyx_CachedCodeObjectType *__pyx__find_code_object(struct __Pyx_CodeObjectCache *code_cache, int code_line) {
+    __Pyx_CachedCodeObjectType* code_object;
     int pos;
-    if (unlikely(!code_line) || unlikely(!__pyx_code_cache.entries)) {
+    if (unlikely(!code_line) || unlikely(!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)) {
+    pos = __pyx_bisect_code_objects(code_cache->entries, code_cache->count, code_line);
+    if (unlikely(pos >= code_cache->count) || unlikely(code_cache->entries[pos].code_line != code_line)) {
         return NULL;
     }
-    code_object = __pyx_code_cache.entries[pos].code_object;
+    code_object = 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) {
+static __Pyx_CachedCodeObjectType *__pyx_find_code_object(int code_line) {
+#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING && !CYTHON_ATOMICS
+    (void)__pyx__find_code_object;
+    return NULL; // Most implementation should have atomics. But otherwise, don't make it thread-safe, just miss.
+#else
+    struct __Pyx_CodeObjectCache *code_cache = &__pyx_mstate_global->__pyx_code_cache;
+#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING
+    __pyx_nonatomic_int_type old_count = __pyx_atomic_incr_acq_rel(&code_cache->accessor_count);
+    if (old_count < 0) {
+        __pyx_atomic_decr_acq_rel(&code_cache->accessor_count);
+        return NULL;
+    }
+#endif
+    __Pyx_CachedCodeObjectType *result = __pyx__find_code_object(code_cache, code_line);
+#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING
+    __pyx_atomic_decr_acq_rel(&code_cache->accessor_count);
+#endif
+    return result;
+#endif
+}
+static void __pyx__insert_code_object(struct __Pyx_CodeObjectCache *code_cache, int code_line, __Pyx_CachedCodeObjectType* code_object)
+{
     int pos, i;
-    __Pyx_CodeObjectCacheEntry* entries = __pyx_code_cache.entries;
+    __Pyx_CodeObjectCacheEntry* entries = 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;
+            code_cache->entries = entries;
+            code_cache->max_count = 64;
+            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;
+    pos = __pyx_bisect_code_objects(code_cache->entries, code_cache->count, code_line);
+    if ((pos < code_cache->count) && unlikely(code_cache->entries[pos].code_line == code_line)) {
+        __Pyx_CachedCodeObjectType* tmp = entries[pos].code_object;
         entries[pos].code_object = code_object;
+        Py_INCREF(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;
+    if (code_cache->count == code_cache->max_count) {
+        int new_max = code_cache->max_count + 64;
         entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc(
-            __pyx_code_cache.entries, (size_t)new_max*sizeof(__Pyx_CodeObjectCacheEntry));
+            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;
+        code_cache->entries = entries;
+        code_cache->max_count = new_max;
     }
-    for (i=__pyx_code_cache.count; i>pos; i--) {
+    for (i=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++;
+    code_cache->count++;
     Py_INCREF(code_object);
 }
+static void __pyx_insert_code_object(int code_line, __Pyx_CachedCodeObjectType* code_object) {
+#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING && !CYTHON_ATOMICS
+    (void)__pyx__insert_code_object;
+    return; // Most implementation should have atomics. But otherwise, don't make it thread-safe, just fail.
+#else
+    struct __Pyx_CodeObjectCache *code_cache = &__pyx_mstate_global->__pyx_code_cache;
+#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING
+    __pyx_nonatomic_int_type expected = 0;
+    if (!__pyx_atomic_int_cmp_exchange(&code_cache->accessor_count, &expected, INT_MIN)) {
+        return;
+    }
+#endif
+    __pyx__insert_code_object(code_cache, code_line, code_object);
+#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING
+    __pyx_atomic_sub(&code_cache->accessor_count, INT_MIN);
+#endif
+#endif
+}
 
 /* AddTraceback */
 #include "compile.h"
 #include "frameobject.h"
 #include "traceback.h"
+#if PY_VERSION_HEX >= 0x030b00a6 && !CYTHON_COMPILING_IN_LIMITED_API && !defined(PYPY_VERSION)
+  #ifndef Py_BUILD_CORE
+    #define Py_BUILD_CORE 1
+  #endif
+  #include "internal/pycore_frame.h"
+#endif
+#if CYTHON_COMPILING_IN_LIMITED_API
+static PyObject *__Pyx_PyCode_Replace_For_AddTraceback(PyObject *code, PyObject *scratch_dict,
+                                                       PyObject *firstlineno, PyObject *name) {
+    PyObject *replace = NULL;
+    if (unlikely(PyDict_SetItemString(scratch_dict, "co_firstlineno", firstlineno))) return NULL;
+    if (unlikely(PyDict_SetItemString(scratch_dict, "co_name", name))) return NULL;
+    replace = PyObject_GetAttrString(code, "replace");
+    if (likely(replace)) {
+        PyObject *result = PyObject_Call(replace, __pyx_mstate_global->__pyx_empty_tuple, scratch_dict);
+        Py_DECREF(replace);
+        return result;
+    }
+    PyErr_Clear();
+    return NULL;
+}
+static void __Pyx_AddTraceback(const char *funcname, int c_line,
+                               int py_line, const char *filename) {
+    PyObject *code_object = NULL, *py_py_line = NULL, *py_funcname = NULL, *dict = NULL;
+    PyObject *replace = NULL, *getframe = NULL, *frame = NULL;
+    PyObject *exc_type, *exc_value, *exc_traceback;
+    int success = 0;
+    if (c_line) {
+        (void) __pyx_cfilenm;
+        (void) __Pyx_CLineForTraceback(__Pyx_PyThreadState_Current, c_line);
+    }
+    PyErr_Fetch(&exc_type, &exc_value, &exc_traceback);
+    code_object = __pyx_find_code_object(c_line ? -c_line : py_line);
+    if (!code_object) {
+        code_object = Py_CompileString("_getframe()", filename, Py_eval_input);
+        if (unlikely(!code_object)) goto bad;
+        py_py_line = PyLong_FromLong(py_line);
+        if (unlikely(!py_py_line)) goto bad;
+        py_funcname = PyUnicode_FromString(funcname);
+        if (unlikely(!py_funcname)) goto bad;
+        dict = PyDict_New();
+        if (unlikely(!dict)) goto bad;
+        {
+            PyObject *old_code_object = code_object;
+            code_object = __Pyx_PyCode_Replace_For_AddTraceback(code_object, dict, py_py_line, py_funcname);
+            Py_DECREF(old_code_object);
+        }
+        if (unlikely(!code_object)) goto bad;
+        __pyx_insert_code_object(c_line ? -c_line : py_line, code_object);
+    } else {
+        dict = PyDict_New();
+    }
+    getframe = PySys_GetObject("_getframe");
+    if (unlikely(!getframe)) goto bad;
+    if (unlikely(PyDict_SetItemString(dict, "_getframe", getframe))) goto bad;
+    frame = PyEval_EvalCode(code_object, dict, dict);
+    if (unlikely(!frame) || frame == Py_None) goto bad;
+    success = 1;
+  bad:
+    PyErr_Restore(exc_type, exc_value, exc_traceback);
+    Py_XDECREF(code_object);
+    Py_XDECREF(py_py_line);
+    Py_XDECREF(py_funcname);
+    Py_XDECREF(dict);
+    Py_XDECREF(replace);
+    if (success) {
+        PyTraceBack_Here(
+            (struct _frame*)frame);
+    }
+    Py_XDECREF(frame);
+}
+#else
 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;
+    PyCodeObject *py_code = NULL;
+    PyObject *py_funcname = NULL;
     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;
+        funcname = PyUnicode_AsUTF8(py_funcname);
+        if (!funcname) goto bad;
     }
-    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);
+    py_code = PyCode_NewEmpty(filename, funcname, py_line);
+    Py_XDECREF(py_funcname);
     return py_code;
 bad:
-    Py_XDECREF(py_srcfile);
     Py_XDECREF(py_funcname);
     return NULL;
 }
@@ -73265,302 +95178,65 @@ static void __Pyx_AddTraceback(const char *funcname, int c_line,
     PyCodeObject *py_code = 0;
     PyFrameObject *py_frame = 0;
     PyThreadState *tstate = __Pyx_PyThreadState_Current;
+    PyObject *ptype, *pvalue, *ptraceback;
     if (c_line) {
         c_line = __Pyx_CLineForTraceback(tstate, c_line);
     }
     py_code = __pyx_find_code_object(c_line ? -c_line : py_line);
     if (!py_code) {
+        __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback);
         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(
-        tstate,            /*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);
-}
-
-/* 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_TA_RetCode(TA_RetCode value) {
-    const TA_RetCode neg_one = (TA_RetCode) ((TA_RetCode) 0 - (TA_RetCode) 1), const_zero = (TA_RetCode) 0;
-    const int is_unsigned = neg_one > const_zero;
-    if (is_unsigned) {
-        if (sizeof(TA_RetCode) < sizeof(long)) {
-            return PyInt_FromLong((long) value);
-        } else if (sizeof(TA_RetCode) <= sizeof(unsigned long)) {
-            return PyLong_FromUnsignedLong((unsigned long) value);
-#ifdef HAVE_LONG_LONG
-        } else if (sizeof(TA_RetCode) <= sizeof(unsigned PY_LONG_LONG)) {
-            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
-#endif
-        }
-    } else {
-        if (sizeof(TA_RetCode) <= sizeof(long)) {
-            return PyInt_FromLong((long) value);
-#ifdef HAVE_LONG_LONG
-        } else if (sizeof(TA_RetCode) <= 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(TA_RetCode),
-                                     little, !is_unsigned);
-    }
-}
-
-/* CIntToPy */
-static CYTHON_INLINE PyObject* __Pyx_PyInt_From_unsigned_int(unsigned int value) {
-    const unsigned int neg_one = (unsigned int) ((unsigned int) 0 - (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);
-    }
-}
-
-/* CIntToPy */
-static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) {
-    const int neg_one = (int) ((int) 0 - (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_long(long value) {
-    const long neg_one = (long) ((long) 0 - (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);
-    }
-}
-
-/* CIntToPy */
-static CYTHON_INLINE PyObject* __Pyx_PyInt_From_TA_OptInputParameterType(TA_OptInputParameterType value) {
-    const TA_OptInputParameterType neg_one = (TA_OptInputParameterType) ((TA_OptInputParameterType) 0 - (TA_OptInputParameterType) 1), const_zero = (TA_OptInputParameterType) 0;
-    const int is_unsigned = neg_one > const_zero;
-    if (is_unsigned) {
-        if (sizeof(TA_OptInputParameterType) < sizeof(long)) {
-            return PyInt_FromLong((long) value);
-        } else if (sizeof(TA_OptInputParameterType) <= sizeof(unsigned long)) {
-            return PyLong_FromUnsignedLong((unsigned long) value);
-#ifdef HAVE_LONG_LONG
-        } else if (sizeof(TA_OptInputParameterType) <= sizeof(unsigned PY_LONG_LONG)) {
-            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
-#endif
-        }
-    } else {
-        if (sizeof(TA_OptInputParameterType) <= sizeof(long)) {
-            return PyInt_FromLong((long) value);
-#ifdef HAVE_LONG_LONG
-        } else if (sizeof(TA_OptInputParameterType) <= 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(TA_OptInputParameterType),
-                                     little, !is_unsigned);
-    }
-}
-
-/* CIntToPy */
-static CYTHON_INLINE PyObject* __Pyx_PyInt_From_TA_FuncFlags(TA_FuncFlags value) {
-    const TA_FuncFlags neg_one = (TA_FuncFlags) ((TA_FuncFlags) 0 - (TA_FuncFlags) 1), const_zero = (TA_FuncFlags) 0;
-    const int is_unsigned = neg_one > const_zero;
-    if (is_unsigned) {
-        if (sizeof(TA_FuncFlags) < sizeof(long)) {
-            return PyInt_FromLong((long) value);
-        } else if (sizeof(TA_FuncFlags) <= sizeof(unsigned long)) {
-            return PyLong_FromUnsignedLong((unsigned long) value);
-#ifdef HAVE_LONG_LONG
-        } else if (sizeof(TA_FuncFlags) <= sizeof(unsigned PY_LONG_LONG)) {
-            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
-#endif
-        }
-    } else {
-        if (sizeof(TA_FuncFlags) <= sizeof(long)) {
-            return PyInt_FromLong((long) value);
-#ifdef HAVE_LONG_LONG
-        } else if (sizeof(TA_FuncFlags) <= 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(TA_FuncFlags),
-                                     little, !is_unsigned);
-    }
-}
-
-/* CIntToPy */
-static CYTHON_INLINE PyObject* __Pyx_PyInt_From_TA_InputFlags(TA_InputFlags value) {
-    const TA_InputFlags neg_one = (TA_InputFlags) ((TA_InputFlags) 0 - (TA_InputFlags) 1), const_zero = (TA_InputFlags) 0;
-    const int is_unsigned = neg_one > const_zero;
-    if (is_unsigned) {
-        if (sizeof(TA_InputFlags) < sizeof(long)) {
-            return PyInt_FromLong((long) value);
-        } else if (sizeof(TA_InputFlags) <= sizeof(unsigned long)) {
-            return PyLong_FromUnsignedLong((unsigned long) value);
-#ifdef HAVE_LONG_LONG
-        } else if (sizeof(TA_InputFlags) <= sizeof(unsigned PY_LONG_LONG)) {
-            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
-#endif
-        }
-    } else {
-        if (sizeof(TA_InputFlags) <= sizeof(long)) {
-            return PyInt_FromLong((long) value);
-#ifdef HAVE_LONG_LONG
-        } else if (sizeof(TA_InputFlags) <= 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(TA_InputFlags),
-                                     little, !is_unsigned);
-    }
-}
-
-/* CIntToPy */
-static CYTHON_INLINE PyObject* __Pyx_PyInt_From_TA_OutputFlags(TA_OutputFlags value) {
-    const TA_OutputFlags neg_one = (TA_OutputFlags) ((TA_OutputFlags) 0 - (TA_OutputFlags) 1), const_zero = (TA_OutputFlags) 0;
-    const int is_unsigned = neg_one > const_zero;
-    if (is_unsigned) {
-        if (sizeof(TA_OutputFlags) < sizeof(long)) {
-            return PyInt_FromLong((long) value);
-        } else if (sizeof(TA_OutputFlags) <= sizeof(unsigned long)) {
-            return PyLong_FromUnsignedLong((unsigned long) value);
-#ifdef HAVE_LONG_LONG
-        } else if (sizeof(TA_OutputFlags) <= sizeof(unsigned PY_LONG_LONG)) {
-            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
-#endif
-        }
-    } else {
-        if (sizeof(TA_OutputFlags) <= sizeof(long)) {
-            return PyInt_FromLong((long) value);
-#ifdef HAVE_LONG_LONG
-        } else if (sizeof(TA_OutputFlags) <= 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(TA_OutputFlags),
-                                     little, !is_unsigned);
+        if (!py_code) {
+            /* If the code object creation fails, then we should clear the
+               fetched exception references and propagate the new exception */
+            Py_XDECREF(ptype);
+            Py_XDECREF(pvalue);
+            Py_XDECREF(ptraceback);
+            goto bad;
+        }
+        __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback);
+        __pyx_insert_code_object(c_line ? -c_line : py_line, py_code);
     }
+    py_frame = PyFrame_New(
+        tstate,            /*PyThreadState *tstate,*/
+        py_code,           /*PyCodeObject *code,*/
+        __pyx_mstate_global->__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);
 }
+#endif
+
+/* 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
+#if CYTHON_CCOMPLEX && (1) && (!0 || __cplusplus)
   #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);
@@ -73580,7 +95256,7 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_TA_OutputFlags(TA_OutputFlags va
 #endif
 
 /* Arithmetic */
-#if CYTHON_CCOMPLEX
+#if CYTHON_CCOMPLEX && (1) && (!0 || __cplusplus)
 #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);
@@ -73612,13 +95288,13 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_TA_OutputFlags(TA_OutputFlags va
                 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);
+                float s = (float)(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);
+            float s = (float)(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);
         }
@@ -73676,7 +95352,6 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_TA_OutputFlags(TA_OutputFlags va
                     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);
@@ -73689,7 +95364,7 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_TA_OutputFlags(TA_OutputFlags va
             if (a.imag == 0) {
                 if (a.real == 0) {
                     return a;
-                } else if (b.imag == 0) {
+                } else if ((b.imag == 0) && (a.real >= 0)) {
                     z.real = powf(a.real, b.real);
                     z.imag = 0;
                     return z;
@@ -73698,7 +95373,7 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_TA_OutputFlags(TA_OutputFlags va
                     theta = 0;
                 } else {
                     r = -a.real;
-                    theta = atan2f(0, -1);
+                    theta = atan2f(0.0, -1.0);
                 }
             } else {
                 r = __Pyx_c_abs_float(a);
@@ -73715,7 +95390,7 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_TA_OutputFlags(TA_OutputFlags va
 #endif
 
 /* Declarations */
-#if CYTHON_CCOMPLEX
+#if CYTHON_CCOMPLEX && (1) && (!0 || __cplusplus)
   #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);
@@ -73735,7 +95410,7 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_TA_OutputFlags(TA_OutputFlags va
 #endif
 
 /* Arithmetic */
-#if CYTHON_CCOMPLEX
+#if CYTHON_CCOMPLEX && (1) && (!0 || __cplusplus)
 #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);
@@ -73767,13 +95442,13 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_TA_OutputFlags(TA_OutputFlags va
                 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);
+                double s = (double)(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);
+            double s = (double)(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);
         }
@@ -73831,7 +95506,6 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_TA_OutputFlags(TA_OutputFlags va
                     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);
@@ -73844,7 +95518,7 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_TA_OutputFlags(TA_OutputFlags va
             if (a.imag == 0) {
                 if (a.real == 0) {
                     return a;
-                } else if (b.imag == 0) {
+                } else if ((b.imag == 0) && (a.real >= 0)) {
                     z.real = pow(a.real, b.real);
                     z.imag = 0;
                     return z;
@@ -73853,7 +95527,7 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_TA_OutputFlags(TA_OutputFlags va
                     theta = 0;
                 } else {
                     r = -a.real;
-                    theta = atan2(0, -1);
+                    theta = atan2(0.0, -1.0);
                 }
             } else {
                 r = __Pyx_c_abs_double(a);
@@ -73869,214 +95543,402 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_TA_OutputFlags(TA_OutputFlags va
     #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) ((enum NPY_TYPES) 0 - (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);
+/* Declarations */
+#if CYTHON_CCOMPLEX && (1) && (!0 || __cplusplus)
+  #ifdef __cplusplus
+    static CYTHON_INLINE __pyx_t_long_double_complex __pyx_t_long_double_complex_from_parts(long double x, long double y) {
+      return ::std::complex< long double >(x, y);
+    }
+  #else
+    static CYTHON_INLINE __pyx_t_long_double_complex __pyx_t_long_double_complex_from_parts(long double x, long double y) {
+      return x + y*(__pyx_t_long_double_complex)_Complex_I;
+    }
+  #endif
+#else
+    static CYTHON_INLINE __pyx_t_long_double_complex __pyx_t_long_double_complex_from_parts(long double x, long double y) {
+      __pyx_t_long_double_complex z;
+      z.real = x;
+      z.imag = y;
+      return z;
+    }
 #endif
+
+/* Arithmetic */
+#if CYTHON_CCOMPLEX && (1) && (!0 || __cplusplus)
+#else
+    static CYTHON_INLINE int __Pyx_c_eq_long__double(__pyx_t_long_double_complex a, __pyx_t_long_double_complex b) {
+       return (a.real == b.real) && (a.imag == b.imag);
+    }
+    static CYTHON_INLINE __pyx_t_long_double_complex __Pyx_c_sum_long__double(__pyx_t_long_double_complex a, __pyx_t_long_double_complex b) {
+        __pyx_t_long_double_complex z;
+        z.real = a.real + b.real;
+        z.imag = a.imag + b.imag;
+        return z;
+    }
+    static CYTHON_INLINE __pyx_t_long_double_complex __Pyx_c_diff_long__double(__pyx_t_long_double_complex a, __pyx_t_long_double_complex b) {
+        __pyx_t_long_double_complex z;
+        z.real = a.real - b.real;
+        z.imag = a.imag - b.imag;
+        return z;
+    }
+    static CYTHON_INLINE __pyx_t_long_double_complex __Pyx_c_prod_long__double(__pyx_t_long_double_complex a, __pyx_t_long_double_complex b) {
+        __pyx_t_long_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_long_double_complex __Pyx_c_quot_long__double(__pyx_t_long_double_complex a, __pyx_t_long_double_complex b) {
+        if (b.imag == 0) {
+            return __pyx_t_long_double_complex_from_parts(a.real / b.real, a.imag / b.real);
+        } else if (fabsl(b.real) >= fabsl(b.imag)) {
+            if (b.real == 0 && b.imag == 0) {
+                return __pyx_t_long_double_complex_from_parts(a.real / b.real, a.imag / b.imag);
+            } else {
+                long double r = b.imag / b.real;
+                long double s = (long double)(1.0) / (b.real + b.imag * r);
+                return __pyx_t_long_double_complex_from_parts(
+                    (a.real + a.imag * r) * s, (a.imag - a.real * r) * s);
+            }
+        } else {
+            long double r = b.real / b.imag;
+            long double s = (long double)(1.0) / (b.imag + b.real * r);
+            return __pyx_t_long_double_complex_from_parts(
+                (a.real * r + a.imag) * s, (a.imag * r - a.real) * s);
         }
-    } 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
+    }
+    #else
+    static CYTHON_INLINE __pyx_t_long_double_complex __Pyx_c_quot_long__double(__pyx_t_long_double_complex a, __pyx_t_long_double_complex b) {
+        if (b.imag == 0) {
+            return __pyx_t_long_double_complex_from_parts(a.real / b.real, a.imag / b.real);
+        } else {
+            long double denom = b.real * b.real + b.imag * b.imag;
+            return __pyx_t_long_double_complex_from_parts(
+                (a.real * b.real + a.imag * b.imag) / denom,
+                (a.imag * b.real - a.real * b.imag) / denom);
         }
     }
-    {
-        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);
+    #endif
+    static CYTHON_INLINE __pyx_t_long_double_complex __Pyx_c_neg_long__double(__pyx_t_long_double_complex a) {
+        __pyx_t_long_double_complex z;
+        z.real = -a.real;
+        z.imag = -a.imag;
+        return z;
     }
-}
-
-/* CIntFromPy */
-static CYTHON_INLINE TA_RetCode __Pyx_PyInt_As_TA_RetCode(PyObject *x) {
-    const TA_RetCode neg_one = (TA_RetCode) ((TA_RetCode) 0 - (TA_RetCode) 1), const_zero = (TA_RetCode) 0;
-    const int is_unsigned = neg_one > const_zero;
-#if PY_MAJOR_VERSION < 3
-    if (likely(PyInt_Check(x))) {
-        if (sizeof(TA_RetCode) < sizeof(long)) {
-            __PYX_VERIFY_RETURN_INT(TA_RetCode, long, PyInt_AS_LONG(x))
-        } else {
-            long val = PyInt_AS_LONG(x);
-            if (is_unsigned && unlikely(val < 0)) {
-                goto raise_neg_overflow;
+    static CYTHON_INLINE int __Pyx_c_is_zero_long__double(__pyx_t_long_double_complex a) {
+       return (a.real == 0) && (a.imag == 0);
+    }
+    static CYTHON_INLINE __pyx_t_long_double_complex __Pyx_c_conj_long__double(__pyx_t_long_double_complex a) {
+        __pyx_t_long_double_complex z;
+        z.real =  a.real;
+        z.imag = -a.imag;
+        return z;
+    }
+    #if 1
+        static CYTHON_INLINE long double __Pyx_c_abs_long__double(__pyx_t_long_double_complex z) {
+          #if !defined(HAVE_HYPOT) || defined(_MSC_VER)
+            return sqrtl(z.real*z.real + z.imag*z.imag);
+          #else
+            return hypotl(z.real, z.imag);
+          #endif
+        }
+        static CYTHON_INLINE __pyx_t_long_double_complex __Pyx_c_pow_long__double(__pyx_t_long_double_complex a, __pyx_t_long_double_complex b) {
+            __pyx_t_long_double_complex z;
+            long double r, lnr, theta, z_r, z_theta;
+            if (b.imag == 0 && b.real == (int)b.real) {
+                if (b.real < 0) {
+                    long 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:
+                        return __Pyx_c_prod_long__double(a, a);
+                    case 3:
+                        z = __Pyx_c_prod_long__double(a, a);
+                        return __Pyx_c_prod_long__double(z, a);
+                    case 4:
+                        z = __Pyx_c_prod_long__double(a, a);
+                        return __Pyx_c_prod_long__double(z, z);
+                }
+            }
+            if (a.imag == 0) {
+                if (a.real == 0) {
+                    return a;
+                } else if ((b.imag == 0) && (a.real >= 0)) {
+                    z.real = powl(a.real, b.real);
+                    z.imag = 0;
+                    return z;
+                } else if (a.real > 0) {
+                    r = a.real;
+                    theta = 0;
+                } else {
+                    r = -a.real;
+                    theta = atan2l(0.0, -1.0);
+                }
+            } else {
+                r = __Pyx_c_abs_long__double(a);
+                theta = atan2l(a.imag, a.real);
             }
-            return (TA_RetCode) val;
+            lnr = logl(r);
+            z_r = expl(lnr * b.real - theta * b.imag);
+            z_theta = theta * b.real + lnr * b.imag;
+            z.real = z_r * cosl(z_theta);
+            z.imag = z_r * sinl(z_theta);
+            return z;
         }
-    } else
+    #endif
 #endif
-    if (likely(PyLong_Check(x))) {
-        if (is_unsigned) {
+
+/* CIntFromPy */
+static CYTHON_INLINE TA_RetCode __Pyx_PyLong_As_TA_RetCode(PyObject *x) {
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+#endif
+    const TA_RetCode neg_one = (TA_RetCode) -1, const_zero = (TA_RetCode) 0;
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic pop
+#endif
+    const int is_unsigned = neg_one > const_zero;
+    if (unlikely(!PyLong_Check(x))) {
+        TA_RetCode val;
+        PyObject *tmp = __Pyx_PyNumber_Long(x);
+        if (!tmp) return (TA_RetCode) -1;
+        val = __Pyx_PyLong_As_TA_RetCode(tmp);
+        Py_DECREF(tmp);
+        return val;
+    }
+    if (is_unsigned) {
 #if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (TA_RetCode) 0;
-                case  1: __PYX_VERIFY_RETURN_INT(TA_RetCode, digit, digits[0])
+        if (unlikely(__Pyx_PyLong_IsNeg(x))) {
+            goto raise_neg_overflow;
+        } else if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(TA_RetCode, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_DigitCount(x)) {
                 case 2:
-                    if (8 * sizeof(TA_RetCode) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(TA_RetCode) > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(TA_RetCode, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(TA_RetCode) >= 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(TA_RetCode) >= 2 * PyLong_SHIFT)) {
                             return (TA_RetCode) (((((TA_RetCode)digits[1]) << PyLong_SHIFT) | (TA_RetCode)digits[0]));
                         }
                     }
                     break;
                 case 3:
-                    if (8 * sizeof(TA_RetCode) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(TA_RetCode) > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(TA_RetCode, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(TA_RetCode) >= 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(TA_RetCode) >= 3 * PyLong_SHIFT)) {
                             return (TA_RetCode) (((((((TA_RetCode)digits[2]) << PyLong_SHIFT) | (TA_RetCode)digits[1]) << PyLong_SHIFT) | (TA_RetCode)digits[0]));
                         }
                     }
                     break;
                 case 4:
-                    if (8 * sizeof(TA_RetCode) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(TA_RetCode) > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(TA_RetCode, 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(TA_RetCode) >= 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(TA_RetCode) >= 4 * PyLong_SHIFT)) {
                             return (TA_RetCode) (((((((((TA_RetCode)digits[3]) << PyLong_SHIFT) | (TA_RetCode)digits[2]) << PyLong_SHIFT) | (TA_RetCode)digits[1]) << PyLong_SHIFT) | (TA_RetCode)digits[0]));
                         }
                     }
                     break;
             }
+        }
 #endif
-#if CYTHON_COMPILING_IN_CPYTHON
-            if (unlikely(Py_SIZE(x) < 0)) {
-                goto raise_neg_overflow;
-            }
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7
+        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 (TA_RetCode) -1;
-                if (unlikely(result == 1))
-                    goto raise_neg_overflow;
-            }
+        {
+            int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+            if (unlikely(result < 0))
+                return (TA_RetCode) -1;
+            if (unlikely(result == 1))
+                goto raise_neg_overflow;
+        }
 #endif
-            if (sizeof(TA_RetCode) <= sizeof(unsigned long)) {
-                __PYX_VERIFY_RETURN_INT_EXC(TA_RetCode, unsigned long, PyLong_AsUnsignedLong(x))
+        if ((sizeof(TA_RetCode) <= sizeof(unsigned long))) {
+            __PYX_VERIFY_RETURN_INT_EXC(TA_RetCode, unsigned long, PyLong_AsUnsignedLong(x))
 #ifdef HAVE_LONG_LONG
-            } else if (sizeof(TA_RetCode) <= sizeof(unsigned PY_LONG_LONG)) {
-                __PYX_VERIFY_RETURN_INT_EXC(TA_RetCode, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
+        } else if ((sizeof(TA_RetCode) <= sizeof(unsigned PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(TA_RetCode, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
 #endif
-            }
-        } else {
+        }
+    } else {
 #if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (TA_RetCode) 0;
-                case -1: __PYX_VERIFY_RETURN_INT(TA_RetCode, sdigit, (sdigit) (-(sdigit)digits[0]))
-                case  1: __PYX_VERIFY_RETURN_INT(TA_RetCode,  digit, +digits[0])
+        if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(TA_RetCode, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_SignedDigitCount(x)) {
                 case -2:
-                    if (8 * sizeof(TA_RetCode) - 1 > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(TA_RetCode) - 1 > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(TA_RetCode, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(TA_RetCode) - 1 > 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(TA_RetCode) - 1 > 2 * PyLong_SHIFT)) {
                             return (TA_RetCode) (((TA_RetCode)-1)*(((((TA_RetCode)digits[1]) << PyLong_SHIFT) | (TA_RetCode)digits[0])));
                         }
                     }
                     break;
                 case 2:
-                    if (8 * sizeof(TA_RetCode) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(TA_RetCode) > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(TA_RetCode, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(TA_RetCode) - 1 > 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(TA_RetCode) - 1 > 2 * PyLong_SHIFT)) {
                             return (TA_RetCode) ((((((TA_RetCode)digits[1]) << PyLong_SHIFT) | (TA_RetCode)digits[0])));
                         }
                     }
                     break;
                 case -3:
-                    if (8 * sizeof(TA_RetCode) - 1 > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(TA_RetCode) - 1 > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(TA_RetCode, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(TA_RetCode) - 1 > 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(TA_RetCode) - 1 > 3 * PyLong_SHIFT)) {
                             return (TA_RetCode) (((TA_RetCode)-1)*(((((((TA_RetCode)digits[2]) << PyLong_SHIFT) | (TA_RetCode)digits[1]) << PyLong_SHIFT) | (TA_RetCode)digits[0])));
                         }
                     }
                     break;
                 case 3:
-                    if (8 * sizeof(TA_RetCode) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(TA_RetCode) > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(TA_RetCode, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(TA_RetCode) - 1 > 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(TA_RetCode) - 1 > 3 * PyLong_SHIFT)) {
                             return (TA_RetCode) ((((((((TA_RetCode)digits[2]) << PyLong_SHIFT) | (TA_RetCode)digits[1]) << PyLong_SHIFT) | (TA_RetCode)digits[0])));
                         }
                     }
                     break;
                 case -4:
-                    if (8 * sizeof(TA_RetCode) - 1 > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(TA_RetCode) - 1 > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(TA_RetCode, 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(TA_RetCode) - 1 > 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(TA_RetCode) - 1 > 4 * PyLong_SHIFT)) {
                             return (TA_RetCode) (((TA_RetCode)-1)*(((((((((TA_RetCode)digits[3]) << PyLong_SHIFT) | (TA_RetCode)digits[2]) << PyLong_SHIFT) | (TA_RetCode)digits[1]) << PyLong_SHIFT) | (TA_RetCode)digits[0])));
                         }
                     }
                     break;
                 case 4:
-                    if (8 * sizeof(TA_RetCode) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(TA_RetCode) > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(TA_RetCode, 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(TA_RetCode) - 1 > 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(TA_RetCode) - 1 > 4 * PyLong_SHIFT)) {
                             return (TA_RetCode) ((((((((((TA_RetCode)digits[3]) << PyLong_SHIFT) | (TA_RetCode)digits[2]) << PyLong_SHIFT) | (TA_RetCode)digits[1]) << PyLong_SHIFT) | (TA_RetCode)digits[0])));
                         }
                     }
                     break;
             }
+        }
 #endif
-            if (sizeof(TA_RetCode) <= sizeof(long)) {
-                __PYX_VERIFY_RETURN_INT_EXC(TA_RetCode, long, PyLong_AsLong(x))
+        if ((sizeof(TA_RetCode) <= sizeof(long))) {
+            __PYX_VERIFY_RETURN_INT_EXC(TA_RetCode, long, PyLong_AsLong(x))
 #ifdef HAVE_LONG_LONG
-            } else if (sizeof(TA_RetCode) <= sizeof(PY_LONG_LONG)) {
-                __PYX_VERIFY_RETURN_INT_EXC(TA_RetCode, PY_LONG_LONG, PyLong_AsLongLong(x))
+        } else if ((sizeof(TA_RetCode) <= sizeof(PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(TA_RetCode, PY_LONG_LONG, PyLong_AsLongLong(x))
 #endif
-            }
+        }
+    }
+    {
+        TA_RetCode val;
+        int ret = -1;
+#if PY_VERSION_HEX >= 0x030d00A6 && !CYTHON_COMPILING_IN_LIMITED_API
+        Py_ssize_t bytes_copied = PyLong_AsNativeBytes(
+            x, &val, sizeof(val), Py_ASNATIVEBYTES_NATIVE_ENDIAN | (is_unsigned ? Py_ASNATIVEBYTES_UNSIGNED_BUFFER | Py_ASNATIVEBYTES_REJECT_NEGATIVE : 0));
+        if (unlikely(bytes_copied == -1)) {
+        } else if (unlikely(bytes_copied > (Py_ssize_t) sizeof(val))) {
+            goto raise_overflow;
+        } else {
+            ret = 0;
+        }
+#elif PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray)
+        int one = 1; int is_little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&val;
+        ret = _PyLong_AsByteArray((PyLongObject *)x,
+                                    bytes, sizeof(val),
+                                    is_little, !is_unsigned);
+#else
+        PyObject *v;
+        PyObject *stepval = NULL, *mask = NULL, *shift = NULL;
+        int bits, remaining_bits, is_negative = 0;
+        int chunk_size = (sizeof(long) < 8) ? 30 : 62;
+        if (likely(PyLong_CheckExact(x))) {
+            v = __Pyx_NewRef(x);
+        } else {
+            v = PyNumber_Long(x);
+            if (unlikely(!v)) return (TA_RetCode) -1;
+            assert(PyLong_CheckExact(v));
         }
         {
-#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
-            PyErr_SetString(PyExc_RuntimeError,
-                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
-#else
-            TA_RetCode 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);
+            int result = PyObject_RichCompareBool(v, Py_False, Py_LT);
+            if (unlikely(result < 0)) {
                 Py_DECREF(v);
-                if (likely(!ret))
-                    return val;
+                return (TA_RetCode) -1;
             }
+            is_negative = result == 1;
+        }
+        if (is_unsigned && unlikely(is_negative)) {
+            Py_DECREF(v);
+            goto raise_neg_overflow;
+        } else if (is_negative) {
+            stepval = PyNumber_Invert(v);
+            Py_DECREF(v);
+            if (unlikely(!stepval))
+                return (TA_RetCode) -1;
+        } else {
+            stepval = v;
+        }
+        v = NULL;
+        val = (TA_RetCode) 0;
+        mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done;
+        shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done;
+        for (bits = 0; bits < (int) sizeof(TA_RetCode) * 8 - chunk_size; bits += chunk_size) {
+            PyObject *tmp, *digit;
+            long idigit;
+            digit = PyNumber_And(stepval, mask);
+            if (unlikely(!digit)) goto done;
+            idigit = PyLong_AsLong(digit);
+            Py_DECREF(digit);
+            if (unlikely(idigit < 0)) goto done;
+            val |= ((TA_RetCode) idigit) << bits;
+            tmp = PyNumber_Rshift(stepval, shift);
+            if (unlikely(!tmp)) goto done;
+            Py_DECREF(stepval); stepval = tmp;
+        }
+        Py_DECREF(shift); shift = NULL;
+        Py_DECREF(mask); mask = NULL;
+        {
+            long idigit = PyLong_AsLong(stepval);
+            if (unlikely(idigit < 0)) goto done;
+            remaining_bits = ((int) sizeof(TA_RetCode) * 8) - bits - (is_unsigned ? 0 : 1);
+            if (unlikely(idigit >= (1L << remaining_bits)))
+                goto raise_overflow;
+            val |= ((TA_RetCode) idigit) << bits;
+        }
+        if (!is_unsigned) {
+            if (unlikely(val & (((TA_RetCode) 1) << (sizeof(TA_RetCode) * 8 - 1))))
+                goto raise_overflow;
+            if (is_negative)
+                val = ~val;
+        }
+        ret = 0;
+    done:
+        Py_XDECREF(shift);
+        Py_XDECREF(mask);
+        Py_XDECREF(stepval);
 #endif
+        if (unlikely(ret))
             return (TA_RetCode) -1;
-        }
-    } else {
-        TA_RetCode val;
-        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
-        if (!tmp) return (TA_RetCode) -1;
-        val = __Pyx_PyInt_As_TA_RetCode(tmp);
-        Py_DECREF(tmp);
         return val;
     }
 raise_overflow:
@@ -74090,182 +95952,247 @@ static CYTHON_INLINE TA_RetCode __Pyx_PyInt_As_TA_RetCode(PyObject *x) {
 }
 
 /* CIntFromPy */
-static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) {
-    const int neg_one = (int) ((int) 0 - (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
+static CYTHON_INLINE int __Pyx_PyLong_As_int(PyObject *x) {
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
 #endif
-    if (likely(PyLong_Check(x))) {
-        if (is_unsigned) {
+    const int neg_one = (int) -1, const_zero = (int) 0;
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic pop
+#endif
+    const int is_unsigned = neg_one > const_zero;
+    if (unlikely(!PyLong_Check(x))) {
+        int val;
+        PyObject *tmp = __Pyx_PyNumber_Long(x);
+        if (!tmp) return (int) -1;
+        val = __Pyx_PyLong_As_int(tmp);
+        Py_DECREF(tmp);
+        return val;
+    }
+    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])
+        if (unlikely(__Pyx_PyLong_IsNeg(x))) {
+            goto raise_neg_overflow;
+        } else if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(int, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_DigitCount(x)) {
                 case 2:
-                    if (8 * sizeof(int) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    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) {
+                        } 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) {
+                    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) {
+                        } 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) {
+                    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) {
+                        } 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;
-            }
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7
+        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;
-            }
+        {
+            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))
+        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))
+        } else if ((sizeof(int) <= sizeof(unsigned PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
 #endif
-            }
-        } else {
+        }
+    } 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])
+        if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(int, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_SignedDigitCount(x)) {
                 case -2:
-                    if (8 * sizeof(int) - 1 > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    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) {
+                        } 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) {
+                    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) {
+                        } 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) {
+                    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) {
+                        } 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) {
+                    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) {
+                        } 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) {
+                    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) {
+                        } 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) {
+                    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) {
+                        } 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))
+        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))
+        } else if ((sizeof(int) <= sizeof(PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x))
 #endif
-            }
+        }
+    }
+    {
+        int val;
+        int ret = -1;
+#if PY_VERSION_HEX >= 0x030d00A6 && !CYTHON_COMPILING_IN_LIMITED_API
+        Py_ssize_t bytes_copied = PyLong_AsNativeBytes(
+            x, &val, sizeof(val), Py_ASNATIVEBYTES_NATIVE_ENDIAN | (is_unsigned ? Py_ASNATIVEBYTES_UNSIGNED_BUFFER | Py_ASNATIVEBYTES_REJECT_NEGATIVE : 0));
+        if (unlikely(bytes_copied == -1)) {
+        } else if (unlikely(bytes_copied > (Py_ssize_t) sizeof(val))) {
+            goto raise_overflow;
+        } else {
+            ret = 0;
+        }
+#elif PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray)
+        int one = 1; int is_little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&val;
+        ret = _PyLong_AsByteArray((PyLongObject *)x,
+                                    bytes, sizeof(val),
+                                    is_little, !is_unsigned);
+#else
+        PyObject *v;
+        PyObject *stepval = NULL, *mask = NULL, *shift = NULL;
+        int bits, remaining_bits, is_negative = 0;
+        int chunk_size = (sizeof(long) < 8) ? 30 : 62;
+        if (likely(PyLong_CheckExact(x))) {
+            v = __Pyx_NewRef(x);
+        } else {
+            v = PyNumber_Long(x);
+            if (unlikely(!v)) return (int) -1;
+            assert(PyLong_CheckExact(v));
         }
         {
-#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);
+            int result = PyObject_RichCompareBool(v, Py_False, Py_LT);
+            if (unlikely(result < 0)) {
                 Py_DECREF(v);
-                if (likely(!ret))
-                    return val;
+                return (int) -1;
             }
+            is_negative = result == 1;
+        }
+        if (is_unsigned && unlikely(is_negative)) {
+            Py_DECREF(v);
+            goto raise_neg_overflow;
+        } else if (is_negative) {
+            stepval = PyNumber_Invert(v);
+            Py_DECREF(v);
+            if (unlikely(!stepval))
+                return (int) -1;
+        } else {
+            stepval = v;
+        }
+        v = NULL;
+        val = (int) 0;
+        mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done;
+        shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done;
+        for (bits = 0; bits < (int) sizeof(int) * 8 - chunk_size; bits += chunk_size) {
+            PyObject *tmp, *digit;
+            long idigit;
+            digit = PyNumber_And(stepval, mask);
+            if (unlikely(!digit)) goto done;
+            idigit = PyLong_AsLong(digit);
+            Py_DECREF(digit);
+            if (unlikely(idigit < 0)) goto done;
+            val |= ((int) idigit) << bits;
+            tmp = PyNumber_Rshift(stepval, shift);
+            if (unlikely(!tmp)) goto done;
+            Py_DECREF(stepval); stepval = tmp;
+        }
+        Py_DECREF(shift); shift = NULL;
+        Py_DECREF(mask); mask = NULL;
+        {
+            long idigit = PyLong_AsLong(stepval);
+            if (unlikely(idigit < 0)) goto done;
+            remaining_bits = ((int) sizeof(int) * 8) - bits - (is_unsigned ? 0 : 1);
+            if (unlikely(idigit >= (1L << remaining_bits)))
+                goto raise_overflow;
+            val |= ((int) idigit) << bits;
+        }
+        if (!is_unsigned) {
+            if (unlikely(val & (((int) 1) << (sizeof(int) * 8 - 1))))
+                goto raise_overflow;
+            if (is_negative)
+                val = ~val;
+        }
+        ret = 0;
+    done:
+        Py_XDECREF(shift);
+        Py_XDECREF(mask);
+        Py_XDECREF(stepval);
 #endif
+        if (unlikely(ret))
             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:
@@ -74278,183 +96205,390 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) {
     return (int) -1;
 }
 
-/* CIntFromPy */
-static CYTHON_INLINE TA_FuncUnstId __Pyx_PyInt_As_TA_FuncUnstId(PyObject *x) {
-    const TA_FuncUnstId neg_one = (TA_FuncUnstId) ((TA_FuncUnstId) 0 - (TA_FuncUnstId) 1), const_zero = (TA_FuncUnstId) 0;
+/* CIntToPy */
+static CYTHON_INLINE PyObject* __Pyx_PyLong_From_int(int value) {
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+#endif
+    const int neg_one = (int) -1, const_zero = (int) 0;
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic pop
+#endif
     const int is_unsigned = neg_one > const_zero;
-#if PY_MAJOR_VERSION < 3
-    if (likely(PyInt_Check(x))) {
-        if (sizeof(TA_FuncUnstId) < sizeof(long)) {
-            __PYX_VERIFY_RETURN_INT(TA_FuncUnstId, long, PyInt_AS_LONG(x))
+    if (is_unsigned) {
+        if (sizeof(int) < sizeof(long)) {
+            return PyLong_FromLong((long) value);
+        } else if (sizeof(int) <= sizeof(unsigned long)) {
+            return PyLong_FromUnsignedLong((unsigned long) value);
+#if defined(HAVE_LONG_LONG) && !CYTHON_COMPILING_IN_PYPY
+        } 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 PyLong_FromLong((long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) {
+            return PyLong_FromLongLong((PY_LONG_LONG) value);
+#endif
+        }
+    }
+    {
+        unsigned char *bytes = (unsigned char *)&value;
+#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00A4
+        if (is_unsigned) {
+            return PyLong_FromUnsignedNativeBytes(bytes, sizeof(value), -1);
         } else {
-            long val = PyInt_AS_LONG(x);
-            if (is_unsigned && unlikely(val < 0)) {
-                goto raise_neg_overflow;
+            return PyLong_FromNativeBytes(bytes, sizeof(value), -1);
+        }
+#elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        return _PyLong_FromByteArray(bytes, sizeof(int),
+                                     little, !is_unsigned);
+#else
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        PyObject *from_bytes, *result = NULL, *kwds = NULL;
+        PyObject *py_bytes = NULL, *order_str = NULL;
+        from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes");
+        if (!from_bytes) return NULL;
+        py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(int));
+        if (!py_bytes) goto limited_bad;
+        order_str = PyUnicode_FromString(little ? "little" : "big");
+        if (!order_str) goto limited_bad;
+        {
+            PyObject *args[3+(CYTHON_VECTORCALL ? 1 : 0)] = { NULL, py_bytes, order_str };
+            if (!is_unsigned) {
+                kwds = __Pyx_MakeVectorcallBuilderKwds(1);
+                if (!kwds) goto limited_bad;
+                if (__Pyx_VectorcallBuilder_AddArgStr("signed", __Pyx_NewRef(Py_True), kwds, args+3, 0) < 0) goto limited_bad;
             }
-            return (TA_FuncUnstId) val;
+            result = __Pyx_Object_Vectorcall_CallFromBuilder(from_bytes, args+1, 2 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET, kwds);
         }
-    } else
+        limited_bad:
+        Py_XDECREF(kwds);
+        Py_XDECREF(order_str);
+        Py_XDECREF(py_bytes);
+        Py_XDECREF(from_bytes);
+        return result;
+#endif
+    }
+}
+
+/* CIntToPy */
+static CYTHON_INLINE PyObject* __Pyx_PyLong_From_TA_RetCode(TA_RetCode value) {
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+#endif
+    const TA_RetCode neg_one = (TA_RetCode) -1, const_zero = (TA_RetCode) 0;
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic pop
+#endif
+    const int is_unsigned = neg_one > const_zero;
+    if (is_unsigned) {
+        if (sizeof(TA_RetCode) < sizeof(long)) {
+            return PyLong_FromLong((long) value);
+        } else if (sizeof(TA_RetCode) <= sizeof(unsigned long)) {
+            return PyLong_FromUnsignedLong((unsigned long) value);
+#if defined(HAVE_LONG_LONG) && !CYTHON_COMPILING_IN_PYPY
+        } else if (sizeof(TA_RetCode) <= sizeof(unsigned PY_LONG_LONG)) {
+            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
+#endif
+        }
+    } else {
+        if (sizeof(TA_RetCode) <= sizeof(long)) {
+            return PyLong_FromLong((long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(TA_RetCode) <= sizeof(PY_LONG_LONG)) {
+            return PyLong_FromLongLong((PY_LONG_LONG) value);
 #endif
-    if (likely(PyLong_Check(x))) {
+        }
+    }
+    {
+        unsigned char *bytes = (unsigned char *)&value;
+#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00A4
         if (is_unsigned) {
+            return PyLong_FromUnsignedNativeBytes(bytes, sizeof(value), -1);
+        } else {
+            return PyLong_FromNativeBytes(bytes, sizeof(value), -1);
+        }
+#elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        return _PyLong_FromByteArray(bytes, sizeof(TA_RetCode),
+                                     little, !is_unsigned);
+#else
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        PyObject *from_bytes, *result = NULL, *kwds = NULL;
+        PyObject *py_bytes = NULL, *order_str = NULL;
+        from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes");
+        if (!from_bytes) return NULL;
+        py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(TA_RetCode));
+        if (!py_bytes) goto limited_bad;
+        order_str = PyUnicode_FromString(little ? "little" : "big");
+        if (!order_str) goto limited_bad;
+        {
+            PyObject *args[3+(CYTHON_VECTORCALL ? 1 : 0)] = { NULL, py_bytes, order_str };
+            if (!is_unsigned) {
+                kwds = __Pyx_MakeVectorcallBuilderKwds(1);
+                if (!kwds) goto limited_bad;
+                if (__Pyx_VectorcallBuilder_AddArgStr("signed", __Pyx_NewRef(Py_True), kwds, args+3, 0) < 0) goto limited_bad;
+            }
+            result = __Pyx_Object_Vectorcall_CallFromBuilder(from_bytes, args+1, 2 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET, kwds);
+        }
+        limited_bad:
+        Py_XDECREF(kwds);
+        Py_XDECREF(order_str);
+        Py_XDECREF(py_bytes);
+        Py_XDECREF(from_bytes);
+        return result;
+#endif
+    }
+}
+
+/* CIntFromPy */
+static CYTHON_INLINE TA_FuncUnstId __Pyx_PyLong_As_TA_FuncUnstId(PyObject *x) {
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+#endif
+    const TA_FuncUnstId neg_one = (TA_FuncUnstId) -1, const_zero = (TA_FuncUnstId) 0;
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic pop
+#endif
+    const int is_unsigned = neg_one > const_zero;
+    if (unlikely(!PyLong_Check(x))) {
+        TA_FuncUnstId val;
+        PyObject *tmp = __Pyx_PyNumber_Long(x);
+        if (!tmp) return (TA_FuncUnstId) -1;
+        val = __Pyx_PyLong_As_TA_FuncUnstId(tmp);
+        Py_DECREF(tmp);
+        return val;
+    }
+    if (is_unsigned) {
 #if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (TA_FuncUnstId) 0;
-                case  1: __PYX_VERIFY_RETURN_INT(TA_FuncUnstId, digit, digits[0])
+        if (unlikely(__Pyx_PyLong_IsNeg(x))) {
+            goto raise_neg_overflow;
+        } else if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(TA_FuncUnstId, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_DigitCount(x)) {
                 case 2:
-                    if (8 * sizeof(TA_FuncUnstId) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(TA_FuncUnstId) > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(TA_FuncUnstId, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(TA_FuncUnstId) >= 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(TA_FuncUnstId) >= 2 * PyLong_SHIFT)) {
                             return (TA_FuncUnstId) (((((TA_FuncUnstId)digits[1]) << PyLong_SHIFT) | (TA_FuncUnstId)digits[0]));
                         }
                     }
                     break;
                 case 3:
-                    if (8 * sizeof(TA_FuncUnstId) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(TA_FuncUnstId) > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(TA_FuncUnstId, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(TA_FuncUnstId) >= 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(TA_FuncUnstId) >= 3 * PyLong_SHIFT)) {
                             return (TA_FuncUnstId) (((((((TA_FuncUnstId)digits[2]) << PyLong_SHIFT) | (TA_FuncUnstId)digits[1]) << PyLong_SHIFT) | (TA_FuncUnstId)digits[0]));
                         }
                     }
                     break;
                 case 4:
-                    if (8 * sizeof(TA_FuncUnstId) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(TA_FuncUnstId) > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(TA_FuncUnstId, 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(TA_FuncUnstId) >= 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(TA_FuncUnstId) >= 4 * PyLong_SHIFT)) {
                             return (TA_FuncUnstId) (((((((((TA_FuncUnstId)digits[3]) << PyLong_SHIFT) | (TA_FuncUnstId)digits[2]) << PyLong_SHIFT) | (TA_FuncUnstId)digits[1]) << PyLong_SHIFT) | (TA_FuncUnstId)digits[0]));
                         }
                     }
                     break;
             }
+        }
 #endif
-#if CYTHON_COMPILING_IN_CPYTHON
-            if (unlikely(Py_SIZE(x) < 0)) {
-                goto raise_neg_overflow;
-            }
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7
+        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 (TA_FuncUnstId) -1;
-                if (unlikely(result == 1))
-                    goto raise_neg_overflow;
-            }
+        {
+            int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+            if (unlikely(result < 0))
+                return (TA_FuncUnstId) -1;
+            if (unlikely(result == 1))
+                goto raise_neg_overflow;
+        }
 #endif
-            if (sizeof(TA_FuncUnstId) <= sizeof(unsigned long)) {
-                __PYX_VERIFY_RETURN_INT_EXC(TA_FuncUnstId, unsigned long, PyLong_AsUnsignedLong(x))
+        if ((sizeof(TA_FuncUnstId) <= sizeof(unsigned long))) {
+            __PYX_VERIFY_RETURN_INT_EXC(TA_FuncUnstId, unsigned long, PyLong_AsUnsignedLong(x))
 #ifdef HAVE_LONG_LONG
-            } else if (sizeof(TA_FuncUnstId) <= sizeof(unsigned PY_LONG_LONG)) {
-                __PYX_VERIFY_RETURN_INT_EXC(TA_FuncUnstId, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
+        } else if ((sizeof(TA_FuncUnstId) <= sizeof(unsigned PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(TA_FuncUnstId, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
 #endif
-            }
-        } else {
+        }
+    } else {
 #if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (TA_FuncUnstId) 0;
-                case -1: __PYX_VERIFY_RETURN_INT(TA_FuncUnstId, sdigit, (sdigit) (-(sdigit)digits[0]))
-                case  1: __PYX_VERIFY_RETURN_INT(TA_FuncUnstId,  digit, +digits[0])
+        if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(TA_FuncUnstId, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_SignedDigitCount(x)) {
                 case -2:
-                    if (8 * sizeof(TA_FuncUnstId) - 1 > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(TA_FuncUnstId) - 1 > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(TA_FuncUnstId, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(TA_FuncUnstId) - 1 > 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(TA_FuncUnstId) - 1 > 2 * PyLong_SHIFT)) {
                             return (TA_FuncUnstId) (((TA_FuncUnstId)-1)*(((((TA_FuncUnstId)digits[1]) << PyLong_SHIFT) | (TA_FuncUnstId)digits[0])));
                         }
                     }
                     break;
                 case 2:
-                    if (8 * sizeof(TA_FuncUnstId) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(TA_FuncUnstId) > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(TA_FuncUnstId, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(TA_FuncUnstId) - 1 > 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(TA_FuncUnstId) - 1 > 2 * PyLong_SHIFT)) {
                             return (TA_FuncUnstId) ((((((TA_FuncUnstId)digits[1]) << PyLong_SHIFT) | (TA_FuncUnstId)digits[0])));
                         }
                     }
                     break;
                 case -3:
-                    if (8 * sizeof(TA_FuncUnstId) - 1 > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(TA_FuncUnstId) - 1 > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(TA_FuncUnstId, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(TA_FuncUnstId) - 1 > 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(TA_FuncUnstId) - 1 > 3 * PyLong_SHIFT)) {
                             return (TA_FuncUnstId) (((TA_FuncUnstId)-1)*(((((((TA_FuncUnstId)digits[2]) << PyLong_SHIFT) | (TA_FuncUnstId)digits[1]) << PyLong_SHIFT) | (TA_FuncUnstId)digits[0])));
                         }
                     }
                     break;
                 case 3:
-                    if (8 * sizeof(TA_FuncUnstId) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(TA_FuncUnstId) > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(TA_FuncUnstId, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(TA_FuncUnstId) - 1 > 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(TA_FuncUnstId) - 1 > 3 * PyLong_SHIFT)) {
                             return (TA_FuncUnstId) ((((((((TA_FuncUnstId)digits[2]) << PyLong_SHIFT) | (TA_FuncUnstId)digits[1]) << PyLong_SHIFT) | (TA_FuncUnstId)digits[0])));
                         }
                     }
                     break;
                 case -4:
-                    if (8 * sizeof(TA_FuncUnstId) - 1 > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(TA_FuncUnstId) - 1 > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(TA_FuncUnstId, 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(TA_FuncUnstId) - 1 > 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(TA_FuncUnstId) - 1 > 4 * PyLong_SHIFT)) {
                             return (TA_FuncUnstId) (((TA_FuncUnstId)-1)*(((((((((TA_FuncUnstId)digits[3]) << PyLong_SHIFT) | (TA_FuncUnstId)digits[2]) << PyLong_SHIFT) | (TA_FuncUnstId)digits[1]) << PyLong_SHIFT) | (TA_FuncUnstId)digits[0])));
                         }
                     }
                     break;
                 case 4:
-                    if (8 * sizeof(TA_FuncUnstId) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(TA_FuncUnstId) > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(TA_FuncUnstId, 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(TA_FuncUnstId) - 1 > 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(TA_FuncUnstId) - 1 > 4 * PyLong_SHIFT)) {
                             return (TA_FuncUnstId) ((((((((((TA_FuncUnstId)digits[3]) << PyLong_SHIFT) | (TA_FuncUnstId)digits[2]) << PyLong_SHIFT) | (TA_FuncUnstId)digits[1]) << PyLong_SHIFT) | (TA_FuncUnstId)digits[0])));
                         }
                     }
                     break;
             }
+        }
 #endif
-            if (sizeof(TA_FuncUnstId) <= sizeof(long)) {
-                __PYX_VERIFY_RETURN_INT_EXC(TA_FuncUnstId, long, PyLong_AsLong(x))
+        if ((sizeof(TA_FuncUnstId) <= sizeof(long))) {
+            __PYX_VERIFY_RETURN_INT_EXC(TA_FuncUnstId, long, PyLong_AsLong(x))
 #ifdef HAVE_LONG_LONG
-            } else if (sizeof(TA_FuncUnstId) <= sizeof(PY_LONG_LONG)) {
-                __PYX_VERIFY_RETURN_INT_EXC(TA_FuncUnstId, PY_LONG_LONG, PyLong_AsLongLong(x))
+        } else if ((sizeof(TA_FuncUnstId) <= sizeof(PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(TA_FuncUnstId, PY_LONG_LONG, PyLong_AsLongLong(x))
 #endif
-            }
+        }
+    }
+    {
+        TA_FuncUnstId val;
+        int ret = -1;
+#if PY_VERSION_HEX >= 0x030d00A6 && !CYTHON_COMPILING_IN_LIMITED_API
+        Py_ssize_t bytes_copied = PyLong_AsNativeBytes(
+            x, &val, sizeof(val), Py_ASNATIVEBYTES_NATIVE_ENDIAN | (is_unsigned ? Py_ASNATIVEBYTES_UNSIGNED_BUFFER | Py_ASNATIVEBYTES_REJECT_NEGATIVE : 0));
+        if (unlikely(bytes_copied == -1)) {
+        } else if (unlikely(bytes_copied > (Py_ssize_t) sizeof(val))) {
+            goto raise_overflow;
+        } else {
+            ret = 0;
+        }
+#elif PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray)
+        int one = 1; int is_little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&val;
+        ret = _PyLong_AsByteArray((PyLongObject *)x,
+                                    bytes, sizeof(val),
+                                    is_little, !is_unsigned);
+#else
+        PyObject *v;
+        PyObject *stepval = NULL, *mask = NULL, *shift = NULL;
+        int bits, remaining_bits, is_negative = 0;
+        int chunk_size = (sizeof(long) < 8) ? 30 : 62;
+        if (likely(PyLong_CheckExact(x))) {
+            v = __Pyx_NewRef(x);
+        } else {
+            v = PyNumber_Long(x);
+            if (unlikely(!v)) return (TA_FuncUnstId) -1;
+            assert(PyLong_CheckExact(v));
         }
         {
-#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
-            PyErr_SetString(PyExc_RuntimeError,
-                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
-#else
-            TA_FuncUnstId 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);
+            int result = PyObject_RichCompareBool(v, Py_False, Py_LT);
+            if (unlikely(result < 0)) {
                 Py_DECREF(v);
-                if (likely(!ret))
-                    return val;
+                return (TA_FuncUnstId) -1;
             }
+            is_negative = result == 1;
+        }
+        if (is_unsigned && unlikely(is_negative)) {
+            Py_DECREF(v);
+            goto raise_neg_overflow;
+        } else if (is_negative) {
+            stepval = PyNumber_Invert(v);
+            Py_DECREF(v);
+            if (unlikely(!stepval))
+                return (TA_FuncUnstId) -1;
+        } else {
+            stepval = v;
+        }
+        v = NULL;
+        val = (TA_FuncUnstId) 0;
+        mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done;
+        shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done;
+        for (bits = 0; bits < (int) sizeof(TA_FuncUnstId) * 8 - chunk_size; bits += chunk_size) {
+            PyObject *tmp, *digit;
+            long idigit;
+            digit = PyNumber_And(stepval, mask);
+            if (unlikely(!digit)) goto done;
+            idigit = PyLong_AsLong(digit);
+            Py_DECREF(digit);
+            if (unlikely(idigit < 0)) goto done;
+            val |= ((TA_FuncUnstId) idigit) << bits;
+            tmp = PyNumber_Rshift(stepval, shift);
+            if (unlikely(!tmp)) goto done;
+            Py_DECREF(stepval); stepval = tmp;
+        }
+        Py_DECREF(shift); shift = NULL;
+        Py_DECREF(mask); mask = NULL;
+        {
+            long idigit = PyLong_AsLong(stepval);
+            if (unlikely(idigit < 0)) goto done;
+            remaining_bits = ((int) sizeof(TA_FuncUnstId) * 8) - bits - (is_unsigned ? 0 : 1);
+            if (unlikely(idigit >= (1L << remaining_bits)))
+                goto raise_overflow;
+            val |= ((TA_FuncUnstId) idigit) << bits;
+        }
+        if (!is_unsigned) {
+            if (unlikely(val & (((TA_FuncUnstId) 1) << (sizeof(TA_FuncUnstId) * 8 - 1))))
+                goto raise_overflow;
+            if (is_negative)
+                val = ~val;
+        }
+        ret = 0;
+    done:
+        Py_XDECREF(shift);
+        Py_XDECREF(mask);
+        Py_XDECREF(stepval);
 #endif
+        if (unlikely(ret))
             return (TA_FuncUnstId) -1;
-        }
-    } else {
-        TA_FuncUnstId val;
-        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
-        if (!tmp) return (TA_FuncUnstId) -1;
-        val = __Pyx_PyInt_As_TA_FuncUnstId(tmp);
-        Py_DECREF(tmp);
         return val;
     }
 raise_overflow:
@@ -74468,182 +96602,247 @@ static CYTHON_INLINE TA_FuncUnstId __Pyx_PyInt_As_TA_FuncUnstId(PyObject *x) {
 }
 
 /* CIntFromPy */
-static CYTHON_INLINE unsigned int __Pyx_PyInt_As_unsigned_int(PyObject *x) {
-    const unsigned int neg_one = (unsigned int) ((unsigned int) 0 - (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
+static CYTHON_INLINE unsigned int __Pyx_PyLong_As_unsigned_int(PyObject *x) {
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
 #endif
-    if (likely(PyLong_Check(x))) {
-        if (is_unsigned) {
+    const unsigned int neg_one = (unsigned int) -1, const_zero = (unsigned int) 0;
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic pop
+#endif
+    const int is_unsigned = neg_one > const_zero;
+    if (unlikely(!PyLong_Check(x))) {
+        unsigned int val;
+        PyObject *tmp = __Pyx_PyNumber_Long(x);
+        if (!tmp) return (unsigned int) -1;
+        val = __Pyx_PyLong_As_unsigned_int(tmp);
+        Py_DECREF(tmp);
+        return val;
+    }
+    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])
+        if (unlikely(__Pyx_PyLong_IsNeg(x))) {
+            goto raise_neg_overflow;
+        } else if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(unsigned int, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_DigitCount(x)) {
                 case 2:
-                    if (8 * sizeof(unsigned int) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    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) {
+                        } 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) {
+                    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) {
+                        } 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) {
+                    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) {
+                        } 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;
-            }
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7
+        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;
-            }
+        {
+            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))
+        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))
+        } 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 {
+        }
+    } 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])
+        if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(unsigned int, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_SignedDigitCount(x)) {
                 case -2:
-                    if (8 * sizeof(unsigned int) - 1 > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    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) {
+                        } 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) {
+                    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) {
+                        } 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) {
+                    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) {
+                        } 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) {
+                    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) {
+                        } 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) {
+                    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) {
+                        } 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) {
+                    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) {
+                        } 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))
+        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))
+        } else if ((sizeof(unsigned int) <= sizeof(PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(unsigned int, PY_LONG_LONG, PyLong_AsLongLong(x))
 #endif
-            }
+        }
+    }
+    {
+        unsigned int val;
+        int ret = -1;
+#if PY_VERSION_HEX >= 0x030d00A6 && !CYTHON_COMPILING_IN_LIMITED_API
+        Py_ssize_t bytes_copied = PyLong_AsNativeBytes(
+            x, &val, sizeof(val), Py_ASNATIVEBYTES_NATIVE_ENDIAN | (is_unsigned ? Py_ASNATIVEBYTES_UNSIGNED_BUFFER | Py_ASNATIVEBYTES_REJECT_NEGATIVE : 0));
+        if (unlikely(bytes_copied == -1)) {
+        } else if (unlikely(bytes_copied > (Py_ssize_t) sizeof(val))) {
+            goto raise_overflow;
+        } else {
+            ret = 0;
+        }
+#elif PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray)
+        int one = 1; int is_little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&val;
+        ret = _PyLong_AsByteArray((PyLongObject *)x,
+                                    bytes, sizeof(val),
+                                    is_little, !is_unsigned);
+#else
+        PyObject *v;
+        PyObject *stepval = NULL, *mask = NULL, *shift = NULL;
+        int bits, remaining_bits, is_negative = 0;
+        int chunk_size = (sizeof(long) < 8) ? 30 : 62;
+        if (likely(PyLong_CheckExact(x))) {
+            v = __Pyx_NewRef(x);
+        } else {
+            v = PyNumber_Long(x);
+            if (unlikely(!v)) return (unsigned int) -1;
+            assert(PyLong_CheckExact(v));
         }
         {
-#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);
+            int result = PyObject_RichCompareBool(v, Py_False, Py_LT);
+            if (unlikely(result < 0)) {
                 Py_DECREF(v);
-                if (likely(!ret))
-                    return val;
+                return (unsigned int) -1;
             }
+            is_negative = result == 1;
+        }
+        if (is_unsigned && unlikely(is_negative)) {
+            Py_DECREF(v);
+            goto raise_neg_overflow;
+        } else if (is_negative) {
+            stepval = PyNumber_Invert(v);
+            Py_DECREF(v);
+            if (unlikely(!stepval))
+                return (unsigned int) -1;
+        } else {
+            stepval = v;
+        }
+        v = NULL;
+        val = (unsigned int) 0;
+        mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done;
+        shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done;
+        for (bits = 0; bits < (int) sizeof(unsigned int) * 8 - chunk_size; bits += chunk_size) {
+            PyObject *tmp, *digit;
+            long idigit;
+            digit = PyNumber_And(stepval, mask);
+            if (unlikely(!digit)) goto done;
+            idigit = PyLong_AsLong(digit);
+            Py_DECREF(digit);
+            if (unlikely(idigit < 0)) goto done;
+            val |= ((unsigned int) idigit) << bits;
+            tmp = PyNumber_Rshift(stepval, shift);
+            if (unlikely(!tmp)) goto done;
+            Py_DECREF(stepval); stepval = tmp;
+        }
+        Py_DECREF(shift); shift = NULL;
+        Py_DECREF(mask); mask = NULL;
+        {
+            long idigit = PyLong_AsLong(stepval);
+            if (unlikely(idigit < 0)) goto done;
+            remaining_bits = ((int) sizeof(unsigned int) * 8) - bits - (is_unsigned ? 0 : 1);
+            if (unlikely(idigit >= (1L << remaining_bits)))
+                goto raise_overflow;
+            val |= ((unsigned int) idigit) << bits;
+        }
+        if (!is_unsigned) {
+            if (unlikely(val & (((unsigned int) 1) << (sizeof(unsigned int) * 8 - 1))))
+                goto raise_overflow;
+            if (is_negative)
+                val = ~val;
+        }
+        ret = 0;
+    done:
+        Py_XDECREF(shift);
+        Py_XDECREF(mask);
+        Py_XDECREF(stepval);
 #endif
+        if (unlikely(ret))
             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:
@@ -74656,183 +96855,319 @@ static CYTHON_INLINE unsigned int __Pyx_PyInt_As_unsigned_int(PyObject *x) {
     return (unsigned int) -1;
 }
 
-/* CIntFromPy */
-static CYTHON_INLINE TA_Compatibility __Pyx_PyInt_As_TA_Compatibility(PyObject *x) {
-    const TA_Compatibility neg_one = (TA_Compatibility) ((TA_Compatibility) 0 - (TA_Compatibility) 1), const_zero = (TA_Compatibility) 0;
+/* CIntToPy */
+static CYTHON_INLINE PyObject* __Pyx_PyLong_From_unsigned_int(unsigned int value) {
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+#endif
+    const unsigned int neg_one = (unsigned int) -1, const_zero = (unsigned int) 0;
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic pop
+#endif
     const int is_unsigned = neg_one > const_zero;
-#if PY_MAJOR_VERSION < 3
-    if (likely(PyInt_Check(x))) {
-        if (sizeof(TA_Compatibility) < sizeof(long)) {
-            __PYX_VERIFY_RETURN_INT(TA_Compatibility, long, PyInt_AS_LONG(x))
+    if (is_unsigned) {
+        if (sizeof(unsigned int) < sizeof(long)) {
+            return PyLong_FromLong((long) value);
+        } else if (sizeof(unsigned int) <= sizeof(unsigned long)) {
+            return PyLong_FromUnsignedLong((unsigned long) value);
+#if defined(HAVE_LONG_LONG) && !CYTHON_COMPILING_IN_PYPY
+        } 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 PyLong_FromLong((long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(unsigned int) <= sizeof(PY_LONG_LONG)) {
+            return PyLong_FromLongLong((PY_LONG_LONG) value);
+#endif
+        }
+    }
+    {
+        unsigned char *bytes = (unsigned char *)&value;
+#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00A4
+        if (is_unsigned) {
+            return PyLong_FromUnsignedNativeBytes(bytes, sizeof(value), -1);
         } else {
-            long val = PyInt_AS_LONG(x);
-            if (is_unsigned && unlikely(val < 0)) {
-                goto raise_neg_overflow;
+            return PyLong_FromNativeBytes(bytes, sizeof(value), -1);
+        }
+#elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        return _PyLong_FromByteArray(bytes, sizeof(unsigned int),
+                                     little, !is_unsigned);
+#else
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        PyObject *from_bytes, *result = NULL, *kwds = NULL;
+        PyObject *py_bytes = NULL, *order_str = NULL;
+        from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes");
+        if (!from_bytes) return NULL;
+        py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(unsigned int));
+        if (!py_bytes) goto limited_bad;
+        order_str = PyUnicode_FromString(little ? "little" : "big");
+        if (!order_str) goto limited_bad;
+        {
+            PyObject *args[3+(CYTHON_VECTORCALL ? 1 : 0)] = { NULL, py_bytes, order_str };
+            if (!is_unsigned) {
+                kwds = __Pyx_MakeVectorcallBuilderKwds(1);
+                if (!kwds) goto limited_bad;
+                if (__Pyx_VectorcallBuilder_AddArgStr("signed", __Pyx_NewRef(Py_True), kwds, args+3, 0) < 0) goto limited_bad;
             }
-            return (TA_Compatibility) val;
+            result = __Pyx_Object_Vectorcall_CallFromBuilder(from_bytes, args+1, 2 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET, kwds);
         }
-    } else
+        limited_bad:
+        Py_XDECREF(kwds);
+        Py_XDECREF(order_str);
+        Py_XDECREF(py_bytes);
+        Py_XDECREF(from_bytes);
+        return result;
 #endif
-    if (likely(PyLong_Check(x))) {
-        if (is_unsigned) {
+    }
+}
+
+/* CIntFromPy */
+static CYTHON_INLINE TA_Compatibility __Pyx_PyLong_As_TA_Compatibility(PyObject *x) {
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+#endif
+    const TA_Compatibility neg_one = (TA_Compatibility) -1, const_zero = (TA_Compatibility) 0;
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic pop
+#endif
+    const int is_unsigned = neg_one > const_zero;
+    if (unlikely(!PyLong_Check(x))) {
+        TA_Compatibility val;
+        PyObject *tmp = __Pyx_PyNumber_Long(x);
+        if (!tmp) return (TA_Compatibility) -1;
+        val = __Pyx_PyLong_As_TA_Compatibility(tmp);
+        Py_DECREF(tmp);
+        return val;
+    }
+    if (is_unsigned) {
 #if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (TA_Compatibility) 0;
-                case  1: __PYX_VERIFY_RETURN_INT(TA_Compatibility, digit, digits[0])
+        if (unlikely(__Pyx_PyLong_IsNeg(x))) {
+            goto raise_neg_overflow;
+        } else if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(TA_Compatibility, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_DigitCount(x)) {
                 case 2:
-                    if (8 * sizeof(TA_Compatibility) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(TA_Compatibility) > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(TA_Compatibility, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(TA_Compatibility) >= 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(TA_Compatibility) >= 2 * PyLong_SHIFT)) {
                             return (TA_Compatibility) (((((TA_Compatibility)digits[1]) << PyLong_SHIFT) | (TA_Compatibility)digits[0]));
                         }
                     }
                     break;
                 case 3:
-                    if (8 * sizeof(TA_Compatibility) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(TA_Compatibility) > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(TA_Compatibility, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(TA_Compatibility) >= 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(TA_Compatibility) >= 3 * PyLong_SHIFT)) {
                             return (TA_Compatibility) (((((((TA_Compatibility)digits[2]) << PyLong_SHIFT) | (TA_Compatibility)digits[1]) << PyLong_SHIFT) | (TA_Compatibility)digits[0]));
                         }
                     }
                     break;
                 case 4:
-                    if (8 * sizeof(TA_Compatibility) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(TA_Compatibility) > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(TA_Compatibility, 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(TA_Compatibility) >= 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(TA_Compatibility) >= 4 * PyLong_SHIFT)) {
                             return (TA_Compatibility) (((((((((TA_Compatibility)digits[3]) << PyLong_SHIFT) | (TA_Compatibility)digits[2]) << PyLong_SHIFT) | (TA_Compatibility)digits[1]) << PyLong_SHIFT) | (TA_Compatibility)digits[0]));
                         }
                     }
                     break;
             }
+        }
 #endif
-#if CYTHON_COMPILING_IN_CPYTHON
-            if (unlikely(Py_SIZE(x) < 0)) {
-                goto raise_neg_overflow;
-            }
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7
+        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 (TA_Compatibility) -1;
-                if (unlikely(result == 1))
-                    goto raise_neg_overflow;
-            }
+        {
+            int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+            if (unlikely(result < 0))
+                return (TA_Compatibility) -1;
+            if (unlikely(result == 1))
+                goto raise_neg_overflow;
+        }
 #endif
-            if (sizeof(TA_Compatibility) <= sizeof(unsigned long)) {
-                __PYX_VERIFY_RETURN_INT_EXC(TA_Compatibility, unsigned long, PyLong_AsUnsignedLong(x))
+        if ((sizeof(TA_Compatibility) <= sizeof(unsigned long))) {
+            __PYX_VERIFY_RETURN_INT_EXC(TA_Compatibility, unsigned long, PyLong_AsUnsignedLong(x))
 #ifdef HAVE_LONG_LONG
-            } else if (sizeof(TA_Compatibility) <= sizeof(unsigned PY_LONG_LONG)) {
-                __PYX_VERIFY_RETURN_INT_EXC(TA_Compatibility, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
+        } else if ((sizeof(TA_Compatibility) <= sizeof(unsigned PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(TA_Compatibility, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
 #endif
-            }
-        } else {
+        }
+    } else {
 #if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (TA_Compatibility) 0;
-                case -1: __PYX_VERIFY_RETURN_INT(TA_Compatibility, sdigit, (sdigit) (-(sdigit)digits[0]))
-                case  1: __PYX_VERIFY_RETURN_INT(TA_Compatibility,  digit, +digits[0])
+        if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(TA_Compatibility, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_SignedDigitCount(x)) {
                 case -2:
-                    if (8 * sizeof(TA_Compatibility) - 1 > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(TA_Compatibility) - 1 > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(TA_Compatibility, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(TA_Compatibility) - 1 > 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(TA_Compatibility) - 1 > 2 * PyLong_SHIFT)) {
                             return (TA_Compatibility) (((TA_Compatibility)-1)*(((((TA_Compatibility)digits[1]) << PyLong_SHIFT) | (TA_Compatibility)digits[0])));
                         }
                     }
                     break;
                 case 2:
-                    if (8 * sizeof(TA_Compatibility) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(TA_Compatibility) > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(TA_Compatibility, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(TA_Compatibility) - 1 > 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(TA_Compatibility) - 1 > 2 * PyLong_SHIFT)) {
                             return (TA_Compatibility) ((((((TA_Compatibility)digits[1]) << PyLong_SHIFT) | (TA_Compatibility)digits[0])));
                         }
                     }
                     break;
                 case -3:
-                    if (8 * sizeof(TA_Compatibility) - 1 > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(TA_Compatibility) - 1 > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(TA_Compatibility, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(TA_Compatibility) - 1 > 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(TA_Compatibility) - 1 > 3 * PyLong_SHIFT)) {
                             return (TA_Compatibility) (((TA_Compatibility)-1)*(((((((TA_Compatibility)digits[2]) << PyLong_SHIFT) | (TA_Compatibility)digits[1]) << PyLong_SHIFT) | (TA_Compatibility)digits[0])));
                         }
                     }
                     break;
                 case 3:
-                    if (8 * sizeof(TA_Compatibility) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(TA_Compatibility) > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(TA_Compatibility, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(TA_Compatibility) - 1 > 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(TA_Compatibility) - 1 > 3 * PyLong_SHIFT)) {
                             return (TA_Compatibility) ((((((((TA_Compatibility)digits[2]) << PyLong_SHIFT) | (TA_Compatibility)digits[1]) << PyLong_SHIFT) | (TA_Compatibility)digits[0])));
                         }
                     }
                     break;
                 case -4:
-                    if (8 * sizeof(TA_Compatibility) - 1 > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(TA_Compatibility) - 1 > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(TA_Compatibility, 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(TA_Compatibility) - 1 > 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(TA_Compatibility) - 1 > 4 * PyLong_SHIFT)) {
                             return (TA_Compatibility) (((TA_Compatibility)-1)*(((((((((TA_Compatibility)digits[3]) << PyLong_SHIFT) | (TA_Compatibility)digits[2]) << PyLong_SHIFT) | (TA_Compatibility)digits[1]) << PyLong_SHIFT) | (TA_Compatibility)digits[0])));
                         }
                     }
                     break;
                 case 4:
-                    if (8 * sizeof(TA_Compatibility) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(TA_Compatibility) > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(TA_Compatibility, 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(TA_Compatibility) - 1 > 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(TA_Compatibility) - 1 > 4 * PyLong_SHIFT)) {
                             return (TA_Compatibility) ((((((((((TA_Compatibility)digits[3]) << PyLong_SHIFT) | (TA_Compatibility)digits[2]) << PyLong_SHIFT) | (TA_Compatibility)digits[1]) << PyLong_SHIFT) | (TA_Compatibility)digits[0])));
                         }
                     }
                     break;
             }
+        }
 #endif
-            if (sizeof(TA_Compatibility) <= sizeof(long)) {
-                __PYX_VERIFY_RETURN_INT_EXC(TA_Compatibility, long, PyLong_AsLong(x))
+        if ((sizeof(TA_Compatibility) <= sizeof(long))) {
+            __PYX_VERIFY_RETURN_INT_EXC(TA_Compatibility, long, PyLong_AsLong(x))
 #ifdef HAVE_LONG_LONG
-            } else if (sizeof(TA_Compatibility) <= sizeof(PY_LONG_LONG)) {
-                __PYX_VERIFY_RETURN_INT_EXC(TA_Compatibility, PY_LONG_LONG, PyLong_AsLongLong(x))
+        } else if ((sizeof(TA_Compatibility) <= sizeof(PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(TA_Compatibility, PY_LONG_LONG, PyLong_AsLongLong(x))
 #endif
-            }
+        }
+    }
+    {
+        TA_Compatibility val;
+        int ret = -1;
+#if PY_VERSION_HEX >= 0x030d00A6 && !CYTHON_COMPILING_IN_LIMITED_API
+        Py_ssize_t bytes_copied = PyLong_AsNativeBytes(
+            x, &val, sizeof(val), Py_ASNATIVEBYTES_NATIVE_ENDIAN | (is_unsigned ? Py_ASNATIVEBYTES_UNSIGNED_BUFFER | Py_ASNATIVEBYTES_REJECT_NEGATIVE : 0));
+        if (unlikely(bytes_copied == -1)) {
+        } else if (unlikely(bytes_copied > (Py_ssize_t) sizeof(val))) {
+            goto raise_overflow;
+        } else {
+            ret = 0;
+        }
+#elif PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray)
+        int one = 1; int is_little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&val;
+        ret = _PyLong_AsByteArray((PyLongObject *)x,
+                                    bytes, sizeof(val),
+                                    is_little, !is_unsigned);
+#else
+        PyObject *v;
+        PyObject *stepval = NULL, *mask = NULL, *shift = NULL;
+        int bits, remaining_bits, is_negative = 0;
+        int chunk_size = (sizeof(long) < 8) ? 30 : 62;
+        if (likely(PyLong_CheckExact(x))) {
+            v = __Pyx_NewRef(x);
+        } else {
+            v = PyNumber_Long(x);
+            if (unlikely(!v)) return (TA_Compatibility) -1;
+            assert(PyLong_CheckExact(v));
         }
         {
-#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
-            PyErr_SetString(PyExc_RuntimeError,
-                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
-#else
-            TA_Compatibility 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);
+            int result = PyObject_RichCompareBool(v, Py_False, Py_LT);
+            if (unlikely(result < 0)) {
                 Py_DECREF(v);
-                if (likely(!ret))
-                    return val;
+                return (TA_Compatibility) -1;
             }
+            is_negative = result == 1;
+        }
+        if (is_unsigned && unlikely(is_negative)) {
+            Py_DECREF(v);
+            goto raise_neg_overflow;
+        } else if (is_negative) {
+            stepval = PyNumber_Invert(v);
+            Py_DECREF(v);
+            if (unlikely(!stepval))
+                return (TA_Compatibility) -1;
+        } else {
+            stepval = v;
+        }
+        v = NULL;
+        val = (TA_Compatibility) 0;
+        mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done;
+        shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done;
+        for (bits = 0; bits < (int) sizeof(TA_Compatibility) * 8 - chunk_size; bits += chunk_size) {
+            PyObject *tmp, *digit;
+            long idigit;
+            digit = PyNumber_And(stepval, mask);
+            if (unlikely(!digit)) goto done;
+            idigit = PyLong_AsLong(digit);
+            Py_DECREF(digit);
+            if (unlikely(idigit < 0)) goto done;
+            val |= ((TA_Compatibility) idigit) << bits;
+            tmp = PyNumber_Rshift(stepval, shift);
+            if (unlikely(!tmp)) goto done;
+            Py_DECREF(stepval); stepval = tmp;
+        }
+        Py_DECREF(shift); shift = NULL;
+        Py_DECREF(mask); mask = NULL;
+        {
+            long idigit = PyLong_AsLong(stepval);
+            if (unlikely(idigit < 0)) goto done;
+            remaining_bits = ((int) sizeof(TA_Compatibility) * 8) - bits - (is_unsigned ? 0 : 1);
+            if (unlikely(idigit >= (1L << remaining_bits)))
+                goto raise_overflow;
+            val |= ((TA_Compatibility) idigit) << bits;
+        }
+        if (!is_unsigned) {
+            if (unlikely(val & (((TA_Compatibility) 1) << (sizeof(TA_Compatibility) * 8 - 1))))
+                goto raise_overflow;
+            if (is_negative)
+                val = ~val;
+        }
+        ret = 0;
+    done:
+        Py_XDECREF(shift);
+        Py_XDECREF(mask);
+        Py_XDECREF(stepval);
 #endif
+        if (unlikely(ret))
             return (TA_Compatibility) -1;
-        }
-    } else {
-        TA_Compatibility val;
-        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
-        if (!tmp) return (TA_Compatibility) -1;
-        val = __Pyx_PyInt_As_TA_Compatibility(tmp);
-        Py_DECREF(tmp);
         return val;
     }
 raise_overflow:
@@ -74846,182 +97181,247 @@ static CYTHON_INLINE TA_Compatibility __Pyx_PyInt_As_TA_Compatibility(PyObject *
 }
 
 /* CIntFromPy */
-static CYTHON_INLINE TA_CandleSettingType __Pyx_PyInt_As_TA_CandleSettingType(PyObject *x) {
-    const TA_CandleSettingType neg_one = (TA_CandleSettingType) ((TA_CandleSettingType) 0 - (TA_CandleSettingType) 1), const_zero = (TA_CandleSettingType) 0;
-    const int is_unsigned = neg_one > const_zero;
-#if PY_MAJOR_VERSION < 3
-    if (likely(PyInt_Check(x))) {
-        if (sizeof(TA_CandleSettingType) < sizeof(long)) {
-            __PYX_VERIFY_RETURN_INT(TA_CandleSettingType, long, PyInt_AS_LONG(x))
-        } else {
-            long val = PyInt_AS_LONG(x);
-            if (is_unsigned && unlikely(val < 0)) {
-                goto raise_neg_overflow;
-            }
-            return (TA_CandleSettingType) val;
-        }
-    } else
+static CYTHON_INLINE TA_CandleSettingType __Pyx_PyLong_As_TA_CandleSettingType(PyObject *x) {
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
 #endif
-    if (likely(PyLong_Check(x))) {
-        if (is_unsigned) {
+    const TA_CandleSettingType neg_one = (TA_CandleSettingType) -1, const_zero = (TA_CandleSettingType) 0;
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic pop
+#endif
+    const int is_unsigned = neg_one > const_zero;
+    if (unlikely(!PyLong_Check(x))) {
+        TA_CandleSettingType val;
+        PyObject *tmp = __Pyx_PyNumber_Long(x);
+        if (!tmp) return (TA_CandleSettingType) -1;
+        val = __Pyx_PyLong_As_TA_CandleSettingType(tmp);
+        Py_DECREF(tmp);
+        return val;
+    }
+    if (is_unsigned) {
 #if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (TA_CandleSettingType) 0;
-                case  1: __PYX_VERIFY_RETURN_INT(TA_CandleSettingType, digit, digits[0])
+        if (unlikely(__Pyx_PyLong_IsNeg(x))) {
+            goto raise_neg_overflow;
+        } else if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(TA_CandleSettingType, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_DigitCount(x)) {
                 case 2:
-                    if (8 * sizeof(TA_CandleSettingType) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(TA_CandleSettingType) > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(TA_CandleSettingType, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(TA_CandleSettingType) >= 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(TA_CandleSettingType) >= 2 * PyLong_SHIFT)) {
                             return (TA_CandleSettingType) (((((TA_CandleSettingType)digits[1]) << PyLong_SHIFT) | (TA_CandleSettingType)digits[0]));
                         }
                     }
                     break;
                 case 3:
-                    if (8 * sizeof(TA_CandleSettingType) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(TA_CandleSettingType) > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(TA_CandleSettingType, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(TA_CandleSettingType) >= 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(TA_CandleSettingType) >= 3 * PyLong_SHIFT)) {
                             return (TA_CandleSettingType) (((((((TA_CandleSettingType)digits[2]) << PyLong_SHIFT) | (TA_CandleSettingType)digits[1]) << PyLong_SHIFT) | (TA_CandleSettingType)digits[0]));
                         }
                     }
                     break;
                 case 4:
-                    if (8 * sizeof(TA_CandleSettingType) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(TA_CandleSettingType) > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(TA_CandleSettingType, 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(TA_CandleSettingType) >= 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(TA_CandleSettingType) >= 4 * PyLong_SHIFT)) {
                             return (TA_CandleSettingType) (((((((((TA_CandleSettingType)digits[3]) << PyLong_SHIFT) | (TA_CandleSettingType)digits[2]) << PyLong_SHIFT) | (TA_CandleSettingType)digits[1]) << PyLong_SHIFT) | (TA_CandleSettingType)digits[0]));
                         }
                     }
                     break;
             }
+        }
 #endif
-#if CYTHON_COMPILING_IN_CPYTHON
-            if (unlikely(Py_SIZE(x) < 0)) {
-                goto raise_neg_overflow;
-            }
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7
+        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 (TA_CandleSettingType) -1;
-                if (unlikely(result == 1))
-                    goto raise_neg_overflow;
-            }
+        {
+            int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+            if (unlikely(result < 0))
+                return (TA_CandleSettingType) -1;
+            if (unlikely(result == 1))
+                goto raise_neg_overflow;
+        }
 #endif
-            if (sizeof(TA_CandleSettingType) <= sizeof(unsigned long)) {
-                __PYX_VERIFY_RETURN_INT_EXC(TA_CandleSettingType, unsigned long, PyLong_AsUnsignedLong(x))
+        if ((sizeof(TA_CandleSettingType) <= sizeof(unsigned long))) {
+            __PYX_VERIFY_RETURN_INT_EXC(TA_CandleSettingType, unsigned long, PyLong_AsUnsignedLong(x))
 #ifdef HAVE_LONG_LONG
-            } else if (sizeof(TA_CandleSettingType) <= sizeof(unsigned PY_LONG_LONG)) {
-                __PYX_VERIFY_RETURN_INT_EXC(TA_CandleSettingType, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
+        } else if ((sizeof(TA_CandleSettingType) <= sizeof(unsigned PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(TA_CandleSettingType, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
 #endif
-            }
-        } else {
+        }
+    } else {
 #if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (TA_CandleSettingType) 0;
-                case -1: __PYX_VERIFY_RETURN_INT(TA_CandleSettingType, sdigit, (sdigit) (-(sdigit)digits[0]))
-                case  1: __PYX_VERIFY_RETURN_INT(TA_CandleSettingType,  digit, +digits[0])
+        if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(TA_CandleSettingType, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_SignedDigitCount(x)) {
                 case -2:
-                    if (8 * sizeof(TA_CandleSettingType) - 1 > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(TA_CandleSettingType) - 1 > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(TA_CandleSettingType, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(TA_CandleSettingType) - 1 > 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(TA_CandleSettingType) - 1 > 2 * PyLong_SHIFT)) {
                             return (TA_CandleSettingType) (((TA_CandleSettingType)-1)*(((((TA_CandleSettingType)digits[1]) << PyLong_SHIFT) | (TA_CandleSettingType)digits[0])));
                         }
                     }
                     break;
                 case 2:
-                    if (8 * sizeof(TA_CandleSettingType) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(TA_CandleSettingType) > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(TA_CandleSettingType, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(TA_CandleSettingType) - 1 > 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(TA_CandleSettingType) - 1 > 2 * PyLong_SHIFT)) {
                             return (TA_CandleSettingType) ((((((TA_CandleSettingType)digits[1]) << PyLong_SHIFT) | (TA_CandleSettingType)digits[0])));
                         }
                     }
                     break;
                 case -3:
-                    if (8 * sizeof(TA_CandleSettingType) - 1 > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(TA_CandleSettingType) - 1 > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(TA_CandleSettingType, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(TA_CandleSettingType) - 1 > 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(TA_CandleSettingType) - 1 > 3 * PyLong_SHIFT)) {
                             return (TA_CandleSettingType) (((TA_CandleSettingType)-1)*(((((((TA_CandleSettingType)digits[2]) << PyLong_SHIFT) | (TA_CandleSettingType)digits[1]) << PyLong_SHIFT) | (TA_CandleSettingType)digits[0])));
                         }
                     }
                     break;
                 case 3:
-                    if (8 * sizeof(TA_CandleSettingType) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(TA_CandleSettingType) > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(TA_CandleSettingType, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(TA_CandleSettingType) - 1 > 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(TA_CandleSettingType) - 1 > 3 * PyLong_SHIFT)) {
                             return (TA_CandleSettingType) ((((((((TA_CandleSettingType)digits[2]) << PyLong_SHIFT) | (TA_CandleSettingType)digits[1]) << PyLong_SHIFT) | (TA_CandleSettingType)digits[0])));
                         }
                     }
                     break;
                 case -4:
-                    if (8 * sizeof(TA_CandleSettingType) - 1 > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(TA_CandleSettingType) - 1 > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(TA_CandleSettingType, 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(TA_CandleSettingType) - 1 > 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(TA_CandleSettingType) - 1 > 4 * PyLong_SHIFT)) {
                             return (TA_CandleSettingType) (((TA_CandleSettingType)-1)*(((((((((TA_CandleSettingType)digits[3]) << PyLong_SHIFT) | (TA_CandleSettingType)digits[2]) << PyLong_SHIFT) | (TA_CandleSettingType)digits[1]) << PyLong_SHIFT) | (TA_CandleSettingType)digits[0])));
                         }
                     }
                     break;
                 case 4:
-                    if (8 * sizeof(TA_CandleSettingType) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(TA_CandleSettingType) > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(TA_CandleSettingType, 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(TA_CandleSettingType) - 1 > 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(TA_CandleSettingType) - 1 > 4 * PyLong_SHIFT)) {
                             return (TA_CandleSettingType) ((((((((((TA_CandleSettingType)digits[3]) << PyLong_SHIFT) | (TA_CandleSettingType)digits[2]) << PyLong_SHIFT) | (TA_CandleSettingType)digits[1]) << PyLong_SHIFT) | (TA_CandleSettingType)digits[0])));
                         }
                     }
                     break;
             }
+        }
 #endif
-            if (sizeof(TA_CandleSettingType) <= sizeof(long)) {
-                __PYX_VERIFY_RETURN_INT_EXC(TA_CandleSettingType, long, PyLong_AsLong(x))
+        if ((sizeof(TA_CandleSettingType) <= sizeof(long))) {
+            __PYX_VERIFY_RETURN_INT_EXC(TA_CandleSettingType, long, PyLong_AsLong(x))
 #ifdef HAVE_LONG_LONG
-            } else if (sizeof(TA_CandleSettingType) <= sizeof(PY_LONG_LONG)) {
-                __PYX_VERIFY_RETURN_INT_EXC(TA_CandleSettingType, PY_LONG_LONG, PyLong_AsLongLong(x))
+        } else if ((sizeof(TA_CandleSettingType) <= sizeof(PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(TA_CandleSettingType, PY_LONG_LONG, PyLong_AsLongLong(x))
 #endif
-            }
+        }
+    }
+    {
+        TA_CandleSettingType val;
+        int ret = -1;
+#if PY_VERSION_HEX >= 0x030d00A6 && !CYTHON_COMPILING_IN_LIMITED_API
+        Py_ssize_t bytes_copied = PyLong_AsNativeBytes(
+            x, &val, sizeof(val), Py_ASNATIVEBYTES_NATIVE_ENDIAN | (is_unsigned ? Py_ASNATIVEBYTES_UNSIGNED_BUFFER | Py_ASNATIVEBYTES_REJECT_NEGATIVE : 0));
+        if (unlikely(bytes_copied == -1)) {
+        } else if (unlikely(bytes_copied > (Py_ssize_t) sizeof(val))) {
+            goto raise_overflow;
+        } else {
+            ret = 0;
+        }
+#elif PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray)
+        int one = 1; int is_little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&val;
+        ret = _PyLong_AsByteArray((PyLongObject *)x,
+                                    bytes, sizeof(val),
+                                    is_little, !is_unsigned);
+#else
+        PyObject *v;
+        PyObject *stepval = NULL, *mask = NULL, *shift = NULL;
+        int bits, remaining_bits, is_negative = 0;
+        int chunk_size = (sizeof(long) < 8) ? 30 : 62;
+        if (likely(PyLong_CheckExact(x))) {
+            v = __Pyx_NewRef(x);
+        } else {
+            v = PyNumber_Long(x);
+            if (unlikely(!v)) return (TA_CandleSettingType) -1;
+            assert(PyLong_CheckExact(v));
         }
         {
-#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
-            PyErr_SetString(PyExc_RuntimeError,
-                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
-#else
-            TA_CandleSettingType 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);
+            int result = PyObject_RichCompareBool(v, Py_False, Py_LT);
+            if (unlikely(result < 0)) {
                 Py_DECREF(v);
-                if (likely(!ret))
-                    return val;
+                return (TA_CandleSettingType) -1;
             }
+            is_negative = result == 1;
+        }
+        if (is_unsigned && unlikely(is_negative)) {
+            Py_DECREF(v);
+            goto raise_neg_overflow;
+        } else if (is_negative) {
+            stepval = PyNumber_Invert(v);
+            Py_DECREF(v);
+            if (unlikely(!stepval))
+                return (TA_CandleSettingType) -1;
+        } else {
+            stepval = v;
+        }
+        v = NULL;
+        val = (TA_CandleSettingType) 0;
+        mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done;
+        shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done;
+        for (bits = 0; bits < (int) sizeof(TA_CandleSettingType) * 8 - chunk_size; bits += chunk_size) {
+            PyObject *tmp, *digit;
+            long idigit;
+            digit = PyNumber_And(stepval, mask);
+            if (unlikely(!digit)) goto done;
+            idigit = PyLong_AsLong(digit);
+            Py_DECREF(digit);
+            if (unlikely(idigit < 0)) goto done;
+            val |= ((TA_CandleSettingType) idigit) << bits;
+            tmp = PyNumber_Rshift(stepval, shift);
+            if (unlikely(!tmp)) goto done;
+            Py_DECREF(stepval); stepval = tmp;
+        }
+        Py_DECREF(shift); shift = NULL;
+        Py_DECREF(mask); mask = NULL;
+        {
+            long idigit = PyLong_AsLong(stepval);
+            if (unlikely(idigit < 0)) goto done;
+            remaining_bits = ((int) sizeof(TA_CandleSettingType) * 8) - bits - (is_unsigned ? 0 : 1);
+            if (unlikely(idigit >= (1L << remaining_bits)))
+                goto raise_overflow;
+            val |= ((TA_CandleSettingType) idigit) << bits;
+        }
+        if (!is_unsigned) {
+            if (unlikely(val & (((TA_CandleSettingType) 1) << (sizeof(TA_CandleSettingType) * 8 - 1))))
+                goto raise_overflow;
+            if (is_negative)
+                val = ~val;
+        }
+        ret = 0;
+    done:
+        Py_XDECREF(shift);
+        Py_XDECREF(mask);
+        Py_XDECREF(stepval);
 #endif
+        if (unlikely(ret))
             return (TA_CandleSettingType) -1;
-        }
-    } else {
-        TA_CandleSettingType val;
-        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
-        if (!tmp) return (TA_CandleSettingType) -1;
-        val = __Pyx_PyInt_As_TA_CandleSettingType(tmp);
-        Py_DECREF(tmp);
         return val;
     }
 raise_overflow:
@@ -75035,182 +97435,247 @@ static CYTHON_INLINE TA_CandleSettingType __Pyx_PyInt_As_TA_CandleSettingType(Py
 }
 
 /* CIntFromPy */
-static CYTHON_INLINE TA_RangeType __Pyx_PyInt_As_TA_RangeType(PyObject *x) {
-    const TA_RangeType neg_one = (TA_RangeType) ((TA_RangeType) 0 - (TA_RangeType) 1), const_zero = (TA_RangeType) 0;
-    const int is_unsigned = neg_one > const_zero;
-#if PY_MAJOR_VERSION < 3
-    if (likely(PyInt_Check(x))) {
-        if (sizeof(TA_RangeType) < sizeof(long)) {
-            __PYX_VERIFY_RETURN_INT(TA_RangeType, long, PyInt_AS_LONG(x))
-        } else {
-            long val = PyInt_AS_LONG(x);
-            if (is_unsigned && unlikely(val < 0)) {
-                goto raise_neg_overflow;
-            }
-            return (TA_RangeType) val;
-        }
-    } else
+static CYTHON_INLINE TA_RangeType __Pyx_PyLong_As_TA_RangeType(PyObject *x) {
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
 #endif
-    if (likely(PyLong_Check(x))) {
-        if (is_unsigned) {
+    const TA_RangeType neg_one = (TA_RangeType) -1, const_zero = (TA_RangeType) 0;
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic pop
+#endif
+    const int is_unsigned = neg_one > const_zero;
+    if (unlikely(!PyLong_Check(x))) {
+        TA_RangeType val;
+        PyObject *tmp = __Pyx_PyNumber_Long(x);
+        if (!tmp) return (TA_RangeType) -1;
+        val = __Pyx_PyLong_As_TA_RangeType(tmp);
+        Py_DECREF(tmp);
+        return val;
+    }
+    if (is_unsigned) {
 #if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (TA_RangeType) 0;
-                case  1: __PYX_VERIFY_RETURN_INT(TA_RangeType, digit, digits[0])
+        if (unlikely(__Pyx_PyLong_IsNeg(x))) {
+            goto raise_neg_overflow;
+        } else if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(TA_RangeType, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_DigitCount(x)) {
                 case 2:
-                    if (8 * sizeof(TA_RangeType) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(TA_RangeType) > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(TA_RangeType, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(TA_RangeType) >= 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(TA_RangeType) >= 2 * PyLong_SHIFT)) {
                             return (TA_RangeType) (((((TA_RangeType)digits[1]) << PyLong_SHIFT) | (TA_RangeType)digits[0]));
                         }
                     }
                     break;
                 case 3:
-                    if (8 * sizeof(TA_RangeType) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(TA_RangeType) > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(TA_RangeType, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(TA_RangeType) >= 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(TA_RangeType) >= 3 * PyLong_SHIFT)) {
                             return (TA_RangeType) (((((((TA_RangeType)digits[2]) << PyLong_SHIFT) | (TA_RangeType)digits[1]) << PyLong_SHIFT) | (TA_RangeType)digits[0]));
                         }
                     }
                     break;
                 case 4:
-                    if (8 * sizeof(TA_RangeType) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(TA_RangeType) > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(TA_RangeType, 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(TA_RangeType) >= 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(TA_RangeType) >= 4 * PyLong_SHIFT)) {
                             return (TA_RangeType) (((((((((TA_RangeType)digits[3]) << PyLong_SHIFT) | (TA_RangeType)digits[2]) << PyLong_SHIFT) | (TA_RangeType)digits[1]) << PyLong_SHIFT) | (TA_RangeType)digits[0]));
                         }
                     }
                     break;
             }
+        }
 #endif
-#if CYTHON_COMPILING_IN_CPYTHON
-            if (unlikely(Py_SIZE(x) < 0)) {
-                goto raise_neg_overflow;
-            }
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7
+        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 (TA_RangeType) -1;
-                if (unlikely(result == 1))
-                    goto raise_neg_overflow;
-            }
+        {
+            int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+            if (unlikely(result < 0))
+                return (TA_RangeType) -1;
+            if (unlikely(result == 1))
+                goto raise_neg_overflow;
+        }
 #endif
-            if (sizeof(TA_RangeType) <= sizeof(unsigned long)) {
-                __PYX_VERIFY_RETURN_INT_EXC(TA_RangeType, unsigned long, PyLong_AsUnsignedLong(x))
+        if ((sizeof(TA_RangeType) <= sizeof(unsigned long))) {
+            __PYX_VERIFY_RETURN_INT_EXC(TA_RangeType, unsigned long, PyLong_AsUnsignedLong(x))
 #ifdef HAVE_LONG_LONG
-            } else if (sizeof(TA_RangeType) <= sizeof(unsigned PY_LONG_LONG)) {
-                __PYX_VERIFY_RETURN_INT_EXC(TA_RangeType, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
+        } else if ((sizeof(TA_RangeType) <= sizeof(unsigned PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(TA_RangeType, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
 #endif
-            }
-        } else {
+        }
+    } else {
 #if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (TA_RangeType) 0;
-                case -1: __PYX_VERIFY_RETURN_INT(TA_RangeType, sdigit, (sdigit) (-(sdigit)digits[0]))
-                case  1: __PYX_VERIFY_RETURN_INT(TA_RangeType,  digit, +digits[0])
+        if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(TA_RangeType, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_SignedDigitCount(x)) {
                 case -2:
-                    if (8 * sizeof(TA_RangeType) - 1 > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(TA_RangeType) - 1 > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(TA_RangeType, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(TA_RangeType) - 1 > 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(TA_RangeType) - 1 > 2 * PyLong_SHIFT)) {
                             return (TA_RangeType) (((TA_RangeType)-1)*(((((TA_RangeType)digits[1]) << PyLong_SHIFT) | (TA_RangeType)digits[0])));
                         }
                     }
                     break;
                 case 2:
-                    if (8 * sizeof(TA_RangeType) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    if ((8 * sizeof(TA_RangeType) > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(TA_RangeType, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(TA_RangeType) - 1 > 2 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(TA_RangeType) - 1 > 2 * PyLong_SHIFT)) {
                             return (TA_RangeType) ((((((TA_RangeType)digits[1]) << PyLong_SHIFT) | (TA_RangeType)digits[0])));
                         }
                     }
                     break;
                 case -3:
-                    if (8 * sizeof(TA_RangeType) - 1 > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(TA_RangeType) - 1 > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(TA_RangeType, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(TA_RangeType) - 1 > 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(TA_RangeType) - 1 > 3 * PyLong_SHIFT)) {
                             return (TA_RangeType) (((TA_RangeType)-1)*(((((((TA_RangeType)digits[2]) << PyLong_SHIFT) | (TA_RangeType)digits[1]) << PyLong_SHIFT) | (TA_RangeType)digits[0])));
                         }
                     }
                     break;
                 case 3:
-                    if (8 * sizeof(TA_RangeType) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                    if ((8 * sizeof(TA_RangeType) > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(TA_RangeType, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(TA_RangeType) - 1 > 3 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(TA_RangeType) - 1 > 3 * PyLong_SHIFT)) {
                             return (TA_RangeType) ((((((((TA_RangeType)digits[2]) << PyLong_SHIFT) | (TA_RangeType)digits[1]) << PyLong_SHIFT) | (TA_RangeType)digits[0])));
                         }
                     }
                     break;
                 case -4:
-                    if (8 * sizeof(TA_RangeType) - 1 > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(TA_RangeType) - 1 > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(TA_RangeType, 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(TA_RangeType) - 1 > 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(TA_RangeType) - 1 > 4 * PyLong_SHIFT)) {
                             return (TA_RangeType) (((TA_RangeType)-1)*(((((((((TA_RangeType)digits[3]) << PyLong_SHIFT) | (TA_RangeType)digits[2]) << PyLong_SHIFT) | (TA_RangeType)digits[1]) << PyLong_SHIFT) | (TA_RangeType)digits[0])));
                         }
                     }
                     break;
                 case 4:
-                    if (8 * sizeof(TA_RangeType) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                    if ((8 * sizeof(TA_RangeType) > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
                             __PYX_VERIFY_RETURN_INT(TA_RangeType, 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(TA_RangeType) - 1 > 4 * PyLong_SHIFT) {
+                        } else if ((8 * sizeof(TA_RangeType) - 1 > 4 * PyLong_SHIFT)) {
                             return (TA_RangeType) ((((((((((TA_RangeType)digits[3]) << PyLong_SHIFT) | (TA_RangeType)digits[2]) << PyLong_SHIFT) | (TA_RangeType)digits[1]) << PyLong_SHIFT) | (TA_RangeType)digits[0])));
                         }
                     }
                     break;
             }
+        }
 #endif
-            if (sizeof(TA_RangeType) <= sizeof(long)) {
-                __PYX_VERIFY_RETURN_INT_EXC(TA_RangeType, long, PyLong_AsLong(x))
+        if ((sizeof(TA_RangeType) <= sizeof(long))) {
+            __PYX_VERIFY_RETURN_INT_EXC(TA_RangeType, long, PyLong_AsLong(x))
 #ifdef HAVE_LONG_LONG
-            } else if (sizeof(TA_RangeType) <= sizeof(PY_LONG_LONG)) {
-                __PYX_VERIFY_RETURN_INT_EXC(TA_RangeType, PY_LONG_LONG, PyLong_AsLongLong(x))
+        } else if ((sizeof(TA_RangeType) <= sizeof(PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(TA_RangeType, PY_LONG_LONG, PyLong_AsLongLong(x))
 #endif
-            }
+        }
+    }
+    {
+        TA_RangeType val;
+        int ret = -1;
+#if PY_VERSION_HEX >= 0x030d00A6 && !CYTHON_COMPILING_IN_LIMITED_API
+        Py_ssize_t bytes_copied = PyLong_AsNativeBytes(
+            x, &val, sizeof(val), Py_ASNATIVEBYTES_NATIVE_ENDIAN | (is_unsigned ? Py_ASNATIVEBYTES_UNSIGNED_BUFFER | Py_ASNATIVEBYTES_REJECT_NEGATIVE : 0));
+        if (unlikely(bytes_copied == -1)) {
+        } else if (unlikely(bytes_copied > (Py_ssize_t) sizeof(val))) {
+            goto raise_overflow;
+        } else {
+            ret = 0;
+        }
+#elif PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray)
+        int one = 1; int is_little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&val;
+        ret = _PyLong_AsByteArray((PyLongObject *)x,
+                                    bytes, sizeof(val),
+                                    is_little, !is_unsigned);
+#else
+        PyObject *v;
+        PyObject *stepval = NULL, *mask = NULL, *shift = NULL;
+        int bits, remaining_bits, is_negative = 0;
+        int chunk_size = (sizeof(long) < 8) ? 30 : 62;
+        if (likely(PyLong_CheckExact(x))) {
+            v = __Pyx_NewRef(x);
+        } else {
+            v = PyNumber_Long(x);
+            if (unlikely(!v)) return (TA_RangeType) -1;
+            assert(PyLong_CheckExact(v));
         }
         {
-#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
-            PyErr_SetString(PyExc_RuntimeError,
-                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
-#else
-            TA_RangeType 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);
+            int result = PyObject_RichCompareBool(v, Py_False, Py_LT);
+            if (unlikely(result < 0)) {
                 Py_DECREF(v);
-                if (likely(!ret))
-                    return val;
+                return (TA_RangeType) -1;
             }
+            is_negative = result == 1;
+        }
+        if (is_unsigned && unlikely(is_negative)) {
+            Py_DECREF(v);
+            goto raise_neg_overflow;
+        } else if (is_negative) {
+            stepval = PyNumber_Invert(v);
+            Py_DECREF(v);
+            if (unlikely(!stepval))
+                return (TA_RangeType) -1;
+        } else {
+            stepval = v;
+        }
+        v = NULL;
+        val = (TA_RangeType) 0;
+        mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done;
+        shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done;
+        for (bits = 0; bits < (int) sizeof(TA_RangeType) * 8 - chunk_size; bits += chunk_size) {
+            PyObject *tmp, *digit;
+            long idigit;
+            digit = PyNumber_And(stepval, mask);
+            if (unlikely(!digit)) goto done;
+            idigit = PyLong_AsLong(digit);
+            Py_DECREF(digit);
+            if (unlikely(idigit < 0)) goto done;
+            val |= ((TA_RangeType) idigit) << bits;
+            tmp = PyNumber_Rshift(stepval, shift);
+            if (unlikely(!tmp)) goto done;
+            Py_DECREF(stepval); stepval = tmp;
+        }
+        Py_DECREF(shift); shift = NULL;
+        Py_DECREF(mask); mask = NULL;
+        {
+            long idigit = PyLong_AsLong(stepval);
+            if (unlikely(idigit < 0)) goto done;
+            remaining_bits = ((int) sizeof(TA_RangeType) * 8) - bits - (is_unsigned ? 0 : 1);
+            if (unlikely(idigit >= (1L << remaining_bits)))
+                goto raise_overflow;
+            val |= ((TA_RangeType) idigit) << bits;
+        }
+        if (!is_unsigned) {
+            if (unlikely(val & (((TA_RangeType) 1) << (sizeof(TA_RangeType) * 8 - 1))))
+                goto raise_overflow;
+            if (is_negative)
+                val = ~val;
+        }
+        ret = 0;
+    done:
+        Py_XDECREF(shift);
+        Py_XDECREF(mask);
+        Py_XDECREF(stepval);
 #endif
+        if (unlikely(ret))
             return (TA_RangeType) -1;
-        }
-    } else {
-        TA_RangeType val;
-        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
-        if (!tmp) return (TA_RangeType) -1;
-        val = __Pyx_PyInt_As_TA_RangeType(tmp);
-        Py_DECREF(tmp);
         return val;
     }
 raise_overflow:
@@ -75223,183 +97688,642 @@ static CYTHON_INLINE TA_RangeType __Pyx_PyInt_As_TA_RangeType(PyObject *x) {
     return (TA_RangeType) -1;
 }
 
-/* CIntFromPy */
-static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) {
-    const long neg_one = (long) ((long) 0 - (long) 1), const_zero = (long) 0;
+/* CIntToPy */
+static CYTHON_INLINE PyObject* __Pyx_PyLong_From_long(long value) {
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+#endif
+    const long neg_one = (long) -1, const_zero = (long) 0;
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic pop
+#endif
     const int is_unsigned = neg_one > const_zero;
-#if PY_MAJOR_VERSION < 3
-    if (likely(PyInt_Check(x))) {
+    if (is_unsigned) {
         if (sizeof(long) < sizeof(long)) {
-            __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x))
+            return PyLong_FromLong((long) value);
+        } else if (sizeof(long) <= sizeof(unsigned long)) {
+            return PyLong_FromUnsignedLong((unsigned long) value);
+#if defined(HAVE_LONG_LONG) && !CYTHON_COMPILING_IN_PYPY
+        } 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 PyLong_FromLong((long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) {
+            return PyLong_FromLongLong((PY_LONG_LONG) value);
+#endif
+        }
+    }
+    {
+        unsigned char *bytes = (unsigned char *)&value;
+#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00A4
+        if (is_unsigned) {
+            return PyLong_FromUnsignedNativeBytes(bytes, sizeof(value), -1);
         } else {
-            long val = PyInt_AS_LONG(x);
-            if (is_unsigned && unlikely(val < 0)) {
-                goto raise_neg_overflow;
+            return PyLong_FromNativeBytes(bytes, sizeof(value), -1);
+        }
+#elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        return _PyLong_FromByteArray(bytes, sizeof(long),
+                                     little, !is_unsigned);
+#else
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        PyObject *from_bytes, *result = NULL, *kwds = NULL;
+        PyObject *py_bytes = NULL, *order_str = NULL;
+        from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes");
+        if (!from_bytes) return NULL;
+        py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(long));
+        if (!py_bytes) goto limited_bad;
+        order_str = PyUnicode_FromString(little ? "little" : "big");
+        if (!order_str) goto limited_bad;
+        {
+            PyObject *args[3+(CYTHON_VECTORCALL ? 1 : 0)] = { NULL, py_bytes, order_str };
+            if (!is_unsigned) {
+                kwds = __Pyx_MakeVectorcallBuilderKwds(1);
+                if (!kwds) goto limited_bad;
+                if (__Pyx_VectorcallBuilder_AddArgStr("signed", __Pyx_NewRef(Py_True), kwds, args+3, 0) < 0) goto limited_bad;
             }
-            return (long) val;
+            result = __Pyx_Object_Vectorcall_CallFromBuilder(from_bytes, args+1, 2 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET, kwds);
         }
-    } else
+        limited_bad:
+        Py_XDECREF(kwds);
+        Py_XDECREF(order_str);
+        Py_XDECREF(py_bytes);
+        Py_XDECREF(from_bytes);
+        return result;
+#endif
+    }
+}
+
+/* CIntToPy */
+static CYTHON_INLINE PyObject* __Pyx_PyLong_From_TA_OptInputParameterType(TA_OptInputParameterType value) {
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+#endif
+    const TA_OptInputParameterType neg_one = (TA_OptInputParameterType) -1, const_zero = (TA_OptInputParameterType) 0;
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic pop
+#endif
+    const int is_unsigned = neg_one > const_zero;
+    if (is_unsigned) {
+        if (sizeof(TA_OptInputParameterType) < sizeof(long)) {
+            return PyLong_FromLong((long) value);
+        } else if (sizeof(TA_OptInputParameterType) <= sizeof(unsigned long)) {
+            return PyLong_FromUnsignedLong((unsigned long) value);
+#if defined(HAVE_LONG_LONG) && !CYTHON_COMPILING_IN_PYPY
+        } else if (sizeof(TA_OptInputParameterType) <= sizeof(unsigned PY_LONG_LONG)) {
+            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
+#endif
+        }
+    } else {
+        if (sizeof(TA_OptInputParameterType) <= sizeof(long)) {
+            return PyLong_FromLong((long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(TA_OptInputParameterType) <= sizeof(PY_LONG_LONG)) {
+            return PyLong_FromLongLong((PY_LONG_LONG) value);
+#endif
+        }
+    }
+    {
+        unsigned char *bytes = (unsigned char *)&value;
+#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00A4
+        if (is_unsigned) {
+            return PyLong_FromUnsignedNativeBytes(bytes, sizeof(value), -1);
+        } else {
+            return PyLong_FromNativeBytes(bytes, sizeof(value), -1);
+        }
+#elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        return _PyLong_FromByteArray(bytes, sizeof(TA_OptInputParameterType),
+                                     little, !is_unsigned);
+#else
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        PyObject *from_bytes, *result = NULL, *kwds = NULL;
+        PyObject *py_bytes = NULL, *order_str = NULL;
+        from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes");
+        if (!from_bytes) return NULL;
+        py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(TA_OptInputParameterType));
+        if (!py_bytes) goto limited_bad;
+        order_str = PyUnicode_FromString(little ? "little" : "big");
+        if (!order_str) goto limited_bad;
+        {
+            PyObject *args[3+(CYTHON_VECTORCALL ? 1 : 0)] = { NULL, py_bytes, order_str };
+            if (!is_unsigned) {
+                kwds = __Pyx_MakeVectorcallBuilderKwds(1);
+                if (!kwds) goto limited_bad;
+                if (__Pyx_VectorcallBuilder_AddArgStr("signed", __Pyx_NewRef(Py_True), kwds, args+3, 0) < 0) goto limited_bad;
+            }
+            result = __Pyx_Object_Vectorcall_CallFromBuilder(from_bytes, args+1, 2 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET, kwds);
+        }
+        limited_bad:
+        Py_XDECREF(kwds);
+        Py_XDECREF(order_str);
+        Py_XDECREF(py_bytes);
+        Py_XDECREF(from_bytes);
+        return result;
+#endif
+    }
+}
+
+/* CIntToPy */
+static CYTHON_INLINE PyObject* __Pyx_PyLong_From_TA_FuncFlags(TA_FuncFlags value) {
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+#endif
+    const TA_FuncFlags neg_one = (TA_FuncFlags) -1, const_zero = (TA_FuncFlags) 0;
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic pop
+#endif
+    const int is_unsigned = neg_one > const_zero;
+    if (is_unsigned) {
+        if (sizeof(TA_FuncFlags) < sizeof(long)) {
+            return PyLong_FromLong((long) value);
+        } else if (sizeof(TA_FuncFlags) <= sizeof(unsigned long)) {
+            return PyLong_FromUnsignedLong((unsigned long) value);
+#if defined(HAVE_LONG_LONG) && !CYTHON_COMPILING_IN_PYPY
+        } else if (sizeof(TA_FuncFlags) <= sizeof(unsigned PY_LONG_LONG)) {
+            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
+#endif
+        }
+    } else {
+        if (sizeof(TA_FuncFlags) <= sizeof(long)) {
+            return PyLong_FromLong((long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(TA_FuncFlags) <= sizeof(PY_LONG_LONG)) {
+            return PyLong_FromLongLong((PY_LONG_LONG) value);
+#endif
+        }
+    }
+    {
+        unsigned char *bytes = (unsigned char *)&value;
+#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00A4
+        if (is_unsigned) {
+            return PyLong_FromUnsignedNativeBytes(bytes, sizeof(value), -1);
+        } else {
+            return PyLong_FromNativeBytes(bytes, sizeof(value), -1);
+        }
+#elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        return _PyLong_FromByteArray(bytes, sizeof(TA_FuncFlags),
+                                     little, !is_unsigned);
+#else
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        PyObject *from_bytes, *result = NULL, *kwds = NULL;
+        PyObject *py_bytes = NULL, *order_str = NULL;
+        from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes");
+        if (!from_bytes) return NULL;
+        py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(TA_FuncFlags));
+        if (!py_bytes) goto limited_bad;
+        order_str = PyUnicode_FromString(little ? "little" : "big");
+        if (!order_str) goto limited_bad;
+        {
+            PyObject *args[3+(CYTHON_VECTORCALL ? 1 : 0)] = { NULL, py_bytes, order_str };
+            if (!is_unsigned) {
+                kwds = __Pyx_MakeVectorcallBuilderKwds(1);
+                if (!kwds) goto limited_bad;
+                if (__Pyx_VectorcallBuilder_AddArgStr("signed", __Pyx_NewRef(Py_True), kwds, args+3, 0) < 0) goto limited_bad;
+            }
+            result = __Pyx_Object_Vectorcall_CallFromBuilder(from_bytes, args+1, 2 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET, kwds);
+        }
+        limited_bad:
+        Py_XDECREF(kwds);
+        Py_XDECREF(order_str);
+        Py_XDECREF(py_bytes);
+        Py_XDECREF(from_bytes);
+        return result;
+#endif
+    }
+}
+
+/* CIntToPy */
+static CYTHON_INLINE PyObject* __Pyx_PyLong_From_TA_InputFlags(TA_InputFlags value) {
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+#endif
+    const TA_InputFlags neg_one = (TA_InputFlags) -1, const_zero = (TA_InputFlags) 0;
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic pop
+#endif
+    const int is_unsigned = neg_one > const_zero;
+    if (is_unsigned) {
+        if (sizeof(TA_InputFlags) < sizeof(long)) {
+            return PyLong_FromLong((long) value);
+        } else if (sizeof(TA_InputFlags) <= sizeof(unsigned long)) {
+            return PyLong_FromUnsignedLong((unsigned long) value);
+#if defined(HAVE_LONG_LONG) && !CYTHON_COMPILING_IN_PYPY
+        } else if (sizeof(TA_InputFlags) <= sizeof(unsigned PY_LONG_LONG)) {
+            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
+#endif
+        }
+    } else {
+        if (sizeof(TA_InputFlags) <= sizeof(long)) {
+            return PyLong_FromLong((long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(TA_InputFlags) <= sizeof(PY_LONG_LONG)) {
+            return PyLong_FromLongLong((PY_LONG_LONG) value);
+#endif
+        }
+    }
+    {
+        unsigned char *bytes = (unsigned char *)&value;
+#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00A4
+        if (is_unsigned) {
+            return PyLong_FromUnsignedNativeBytes(bytes, sizeof(value), -1);
+        } else {
+            return PyLong_FromNativeBytes(bytes, sizeof(value), -1);
+        }
+#elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        return _PyLong_FromByteArray(bytes, sizeof(TA_InputFlags),
+                                     little, !is_unsigned);
+#else
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        PyObject *from_bytes, *result = NULL, *kwds = NULL;
+        PyObject *py_bytes = NULL, *order_str = NULL;
+        from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes");
+        if (!from_bytes) return NULL;
+        py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(TA_InputFlags));
+        if (!py_bytes) goto limited_bad;
+        order_str = PyUnicode_FromString(little ? "little" : "big");
+        if (!order_str) goto limited_bad;
+        {
+            PyObject *args[3+(CYTHON_VECTORCALL ? 1 : 0)] = { NULL, py_bytes, order_str };
+            if (!is_unsigned) {
+                kwds = __Pyx_MakeVectorcallBuilderKwds(1);
+                if (!kwds) goto limited_bad;
+                if (__Pyx_VectorcallBuilder_AddArgStr("signed", __Pyx_NewRef(Py_True), kwds, args+3, 0) < 0) goto limited_bad;
+            }
+            result = __Pyx_Object_Vectorcall_CallFromBuilder(from_bytes, args+1, 2 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET, kwds);
+        }
+        limited_bad:
+        Py_XDECREF(kwds);
+        Py_XDECREF(order_str);
+        Py_XDECREF(py_bytes);
+        Py_XDECREF(from_bytes);
+        return result;
+#endif
+    }
+}
+
+/* CIntToPy */
+static CYTHON_INLINE PyObject* __Pyx_PyLong_From_TA_OutputFlags(TA_OutputFlags value) {
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+#endif
+    const TA_OutputFlags neg_one = (TA_OutputFlags) -1, const_zero = (TA_OutputFlags) 0;
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic pop
+#endif
+    const int is_unsigned = neg_one > const_zero;
+    if (is_unsigned) {
+        if (sizeof(TA_OutputFlags) < sizeof(long)) {
+            return PyLong_FromLong((long) value);
+        } else if (sizeof(TA_OutputFlags) <= sizeof(unsigned long)) {
+            return PyLong_FromUnsignedLong((unsigned long) value);
+#if defined(HAVE_LONG_LONG) && !CYTHON_COMPILING_IN_PYPY
+        } else if (sizeof(TA_OutputFlags) <= sizeof(unsigned PY_LONG_LONG)) {
+            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
+#endif
+        }
+    } else {
+        if (sizeof(TA_OutputFlags) <= sizeof(long)) {
+            return PyLong_FromLong((long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(TA_OutputFlags) <= sizeof(PY_LONG_LONG)) {
+            return PyLong_FromLongLong((PY_LONG_LONG) value);
 #endif
-    if (likely(PyLong_Check(x))) {
+        }
+    }
+    {
+        unsigned char *bytes = (unsigned char *)&value;
+#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00A4
         if (is_unsigned) {
+            return PyLong_FromUnsignedNativeBytes(bytes, sizeof(value), -1);
+        } else {
+            return PyLong_FromNativeBytes(bytes, sizeof(value), -1);
+        }
+#elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        return _PyLong_FromByteArray(bytes, sizeof(TA_OutputFlags),
+                                     little, !is_unsigned);
+#else
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        PyObject *from_bytes, *result = NULL, *kwds = NULL;
+        PyObject *py_bytes = NULL, *order_str = NULL;
+        from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes");
+        if (!from_bytes) return NULL;
+        py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(TA_OutputFlags));
+        if (!py_bytes) goto limited_bad;
+        order_str = PyUnicode_FromString(little ? "little" : "big");
+        if (!order_str) goto limited_bad;
+        {
+            PyObject *args[3+(CYTHON_VECTORCALL ? 1 : 0)] = { NULL, py_bytes, order_str };
+            if (!is_unsigned) {
+                kwds = __Pyx_MakeVectorcallBuilderKwds(1);
+                if (!kwds) goto limited_bad;
+                if (__Pyx_VectorcallBuilder_AddArgStr("signed", __Pyx_NewRef(Py_True), kwds, args+3, 0) < 0) goto limited_bad;
+            }
+            result = __Pyx_Object_Vectorcall_CallFromBuilder(from_bytes, args+1, 2 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET, kwds);
+        }
+        limited_bad:
+        Py_XDECREF(kwds);
+        Py_XDECREF(order_str);
+        Py_XDECREF(py_bytes);
+        Py_XDECREF(from_bytes);
+        return result;
+#endif
+    }
+}
+
+/* FormatTypeName */
+#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030d0000
+static __Pyx_TypeName
+__Pyx_PyType_GetFullyQualifiedName(PyTypeObject* tp)
+{
+    PyObject *module = NULL, *name = NULL, *result = NULL;
+    #if __PYX_LIMITED_VERSION_HEX < 0x030b0000
+    name = __Pyx_PyObject_GetAttrStr((PyObject *)tp,
+                                               __pyx_mstate_global->__pyx_n_u_qualname);
+    #else
+    name = PyType_GetQualName(tp);
+    #endif
+    if (unlikely(name == NULL) || unlikely(!PyUnicode_Check(name))) goto bad;
+    module = __Pyx_PyObject_GetAttrStr((PyObject *)tp,
+                                               __pyx_mstate_global->__pyx_n_u_module);
+    if (unlikely(module == NULL) || unlikely(!PyUnicode_Check(module))) goto bad;
+    if (PyUnicode_CompareWithASCIIString(module, "builtins") == 0) {
+        result = name;
+        name = NULL;
+        goto done;
+    }
+    result = PyUnicode_FromFormat("%U.%U", module, name);
+    if (unlikely(result == NULL)) goto bad;
+  done:
+    Py_XDECREF(name);
+    Py_XDECREF(module);
+    return result;
+  bad:
+    PyErr_Clear();
+    if (name) {
+        result = name;
+        name = NULL;
+    } else {
+        result = __Pyx_NewRef(__pyx_mstate_global->__pyx_kp_u__15);
+    }
+    goto done;
+}
+#endif
+
+/* CIntFromPy */
+static CYTHON_INLINE long __Pyx_PyLong_As_long(PyObject *x) {
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+#endif
+    const long neg_one = (long) -1, const_zero = (long) 0;
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic pop
+#endif
+    const int is_unsigned = neg_one > const_zero;
+    if (unlikely(!PyLong_Check(x))) {
+        long val;
+        PyObject *tmp = __Pyx_PyNumber_Long(x);
+        if (!tmp) return (long) -1;
+        val = __Pyx_PyLong_As_long(tmp);
+        Py_DECREF(tmp);
+        return val;
+    }
+    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])
+        if (unlikely(__Pyx_PyLong_IsNeg(x))) {
+            goto raise_neg_overflow;
+        } else if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(long, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_DigitCount(x)) {
                 case 2:
-                    if (8 * sizeof(long) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    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) {
+                        } 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) {
+                    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) {
+                        } 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) {
+                    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) {
+                        } 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;
-            }
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7
+        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;
-            }
+        {
+            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))
+        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))
+        } else if ((sizeof(long) <= sizeof(unsigned PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
 #endif
-            }
-        } else {
+        }
+    } 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])
+        if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(long, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_SignedDigitCount(x)) {
                 case -2:
-                    if (8 * sizeof(long) - 1 > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                    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) {
+                        } 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) {
+                    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) {
+                        } 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) {
+                    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) {
+                        } 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) {
+                    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) {
+                        } 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) {
+                    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) {
+                        } 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) {
+                    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) {
+                        } 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))
+        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))
+        } else if ((sizeof(long) <= sizeof(PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x))
 #endif
-            }
+        }
+    }
+    {
+        long val;
+        int ret = -1;
+#if PY_VERSION_HEX >= 0x030d00A6 && !CYTHON_COMPILING_IN_LIMITED_API
+        Py_ssize_t bytes_copied = PyLong_AsNativeBytes(
+            x, &val, sizeof(val), Py_ASNATIVEBYTES_NATIVE_ENDIAN | (is_unsigned ? Py_ASNATIVEBYTES_UNSIGNED_BUFFER | Py_ASNATIVEBYTES_REJECT_NEGATIVE : 0));
+        if (unlikely(bytes_copied == -1)) {
+        } else if (unlikely(bytes_copied > (Py_ssize_t) sizeof(val))) {
+            goto raise_overflow;
+        } else {
+            ret = 0;
+        }
+#elif PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray)
+        int one = 1; int is_little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&val;
+        ret = _PyLong_AsByteArray((PyLongObject *)x,
+                                    bytes, sizeof(val),
+                                    is_little, !is_unsigned);
+#else
+        PyObject *v;
+        PyObject *stepval = NULL, *mask = NULL, *shift = NULL;
+        int bits, remaining_bits, is_negative = 0;
+        int chunk_size = (sizeof(long) < 8) ? 30 : 62;
+        if (likely(PyLong_CheckExact(x))) {
+            v = __Pyx_NewRef(x);
+        } else {
+            v = PyNumber_Long(x);
+            if (unlikely(!v)) return (long) -1;
+            assert(PyLong_CheckExact(v));
         }
         {
-#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);
+            int result = PyObject_RichCompareBool(v, Py_False, Py_LT);
+            if (unlikely(result < 0)) {
                 Py_DECREF(v);
-                if (likely(!ret))
-                    return val;
+                return (long) -1;
             }
+            is_negative = result == 1;
+        }
+        if (is_unsigned && unlikely(is_negative)) {
+            Py_DECREF(v);
+            goto raise_neg_overflow;
+        } else if (is_negative) {
+            stepval = PyNumber_Invert(v);
+            Py_DECREF(v);
+            if (unlikely(!stepval))
+                return (long) -1;
+        } else {
+            stepval = v;
+        }
+        v = NULL;
+        val = (long) 0;
+        mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done;
+        shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done;
+        for (bits = 0; bits < (int) sizeof(long) * 8 - chunk_size; bits += chunk_size) {
+            PyObject *tmp, *digit;
+            long idigit;
+            digit = PyNumber_And(stepval, mask);
+            if (unlikely(!digit)) goto done;
+            idigit = PyLong_AsLong(digit);
+            Py_DECREF(digit);
+            if (unlikely(idigit < 0)) goto done;
+            val |= ((long) idigit) << bits;
+            tmp = PyNumber_Rshift(stepval, shift);
+            if (unlikely(!tmp)) goto done;
+            Py_DECREF(stepval); stepval = tmp;
+        }
+        Py_DECREF(shift); shift = NULL;
+        Py_DECREF(mask); mask = NULL;
+        {
+            long idigit = PyLong_AsLong(stepval);
+            if (unlikely(idigit < 0)) goto done;
+            remaining_bits = ((int) sizeof(long) * 8) - bits - (is_unsigned ? 0 : 1);
+            if (unlikely(idigit >= (1L << remaining_bits)))
+                goto raise_overflow;
+            val |= ((long) idigit) << bits;
+        }
+        if (!is_unsigned) {
+            if (unlikely(val & (((long) 1) << (sizeof(long) * 8 - 1))))
+                goto raise_overflow;
+            if (is_negative)
+                val = ~val;
+        }
+        ret = 0;
+    done:
+        Py_XDECREF(shift);
+        Py_XDECREF(mask);
+        Py_XDECREF(stepval);
 #endif
+        if (unlikely(ret))
             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:
@@ -75416,7 +98340,7 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) {
 #if CYTHON_COMPILING_IN_CPYTHON
 static int __Pyx_InBases(PyTypeObject *a, PyTypeObject *b) {
     while (a) {
-        a = a->tp_base;
+        a = __Pyx_PyType_GetSlot(a, tp_base, PyTypeObject*);
         if (a == b)
             return 1;
     }
@@ -75437,51 +98361,38 @@ static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b) {
     }
     return __Pyx_InBases(a, b);
 }
-#if PY_MAJOR_VERSION == 2
-static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject* exc_type2) {
-    PyObject *exception, *value, *tb;
-    int res;
-    __Pyx_PyThreadState_declare
-    __Pyx_PyThreadState_assign
-    __Pyx_ErrFetch(&exception, &value, &tb);
-    res = exc_type1 ? PyObject_IsSubclass(err, exc_type1) : 0;
-    if (unlikely(res == -1)) {
-        PyErr_WriteUnraisable(err);
-        res = 0;
-    }
-    if (!res) {
-        res = PyObject_IsSubclass(err, exc_type2);
-        if (unlikely(res == -1)) {
-            PyErr_WriteUnraisable(err);
-            res = 0;
+static CYTHON_INLINE int __Pyx_IsAnySubtype2(PyTypeObject *cls, PyTypeObject *a, PyTypeObject *b) {
+    PyObject *mro;
+    if (cls == a || cls == b) return 1;
+    mro = cls->tp_mro;
+    if (likely(mro)) {
+        Py_ssize_t i, n;
+        n = PyTuple_GET_SIZE(mro);
+        for (i = 0; i < n; i++) {
+            PyObject *base = PyTuple_GET_ITEM(mro, i);
+            if (base == (PyObject *)a || base == (PyObject *)b)
+                return 1;
         }
+        return 0;
     }
-    __Pyx_ErrRestore(exception, value, tb);
-    return res;
+    return __Pyx_InBases(cls, a) || __Pyx_InBases(cls, b);
 }
-#else
 static CYTHON_INLINE int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject *exc_type2) {
-    int res = exc_type1 ? __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type1) : 0;
-    if (!res) {
-        res = __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2);
+    if (exc_type1) {
+        return __Pyx_IsAnySubtype2((PyTypeObject*)err, (PyTypeObject*)exc_type1, (PyTypeObject*)exc_type2);
+    } else {
+        return __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2);
     }
-    return res;
 }
-#endif
 static int __Pyx_PyErr_GivenExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) {
     Py_ssize_t i, n;
     assert(PyExceptionClass_Check(exc_type));
     n = PyTuple_GET_SIZE(tuple);
-#if PY_MAJOR_VERSION >= 3
     for (i=0; i<n; i++) {
         if (exc_type == PyTuple_GET_ITEM(tuple, i)) return 1;
     }
-#endif
     for (i=0; i<n; i++) {
         PyObject *t = PyTuple_GET_ITEM(tuple, i);
-        #if PY_MAJOR_VERSION < 3
-        if (likely(exc_type == t)) return 1;
-        #endif
         if (likely(PyExceptionClass_Check(t))) {
             if (__Pyx_inner_PyErr_GivenExceptionMatches2(exc_type, NULL, t)) return 1;
         } else {
@@ -75512,87 +98423,273 @@ static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObj
 }
 #endif
 
+/* GetRuntimeVersion */
+static unsigned long __Pyx_get_runtime_version(void) {
+#if __PYX_LIMITED_VERSION_HEX >= 0x030b0000
+    return Py_Version & ~0xFFUL;
+#else
+    static unsigned long __Pyx_cached_runtime_version = 0;
+    if (__Pyx_cached_runtime_version == 0) {
+        const char* rt_version = Py_GetVersion();
+        unsigned long version = 0;
+        unsigned long factor = 0x01000000UL;
+        unsigned int digit = 0;
+        int i = 0;
+        while (factor) {
+            while ('0' <= rt_version[i] && rt_version[i] <= '9') {
+                digit = digit * 10 + (unsigned int) (rt_version[i] - '0');
+                ++i;
+            }
+            version += factor * digit;
+            if (rt_version[i] != '.')
+                break;
+            digit = 0;
+            factor >>= 8;
+            ++i;
+        }
+        __Pyx_cached_runtime_version = version;
+    }
+    return __Pyx_cached_runtime_version;
+#endif
+}
+
 /* 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]) {
+static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt_version, int allow_newer) {
+    const unsigned long MAJOR_MINOR = 0xFFFF0000UL;
+    if ((rt_version & MAJOR_MINOR) == (ct_version & MAJOR_MINOR))
+        return 0;
+    if (likely(allow_newer && (rt_version & MAJOR_MINOR) > (ct_version & MAJOR_MINOR)))
+        return 1;
+    {
         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);
+                      "compile time Python version %d.%d "
+                      "of module '%.100s' "
+                      "%s "
+                      "runtime version %d.%d",
+                       (int) (ct_version >> 24), (int) ((ct_version >> 16) & 0xFF),
+                       __Pyx_MODULE_NAME,
+                       (allow_newer) ? "was newer than" : "does not match",
+                       (int) (rt_version >> 24), (int) ((rt_version >> 16) & 0xFF)
+       );
         return PyErr_WarnEx(NULL, message, 1);
     }
-    return 0;
 }
 
-/* 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);
+/* NewCodeObj */
+#if CYTHON_COMPILING_IN_LIMITED_API
+    static PyObject* __Pyx__PyCode_New(int a, int p, int k, int l, int s, int f,
+                                       PyObject *code, PyObject *c, PyObject* n, PyObject *v,
+                                       PyObject *fv, PyObject *cell, PyObject* fn,
+                                       PyObject *name, int fline, PyObject *lnos) {
+        PyObject *exception_table = NULL;
+        PyObject *types_module=NULL, *code_type=NULL, *result=NULL;
+        #if __PYX_LIMITED_VERSION_HEX < 0x030b0000
+        PyObject *version_info;
+        PyObject *py_minor_version = NULL;
+        #endif
+        long minor_version = 0;
+        PyObject *type, *value, *traceback;
+        PyErr_Fetch(&type, &value, &traceback);
+        #if __PYX_LIMITED_VERSION_HEX >= 0x030b0000
+        minor_version = 11;
+        #else
+        if (!(version_info = PySys_GetObject("version_info"))) goto end;
+        if (!(py_minor_version = PySequence_GetItem(version_info, 1))) goto end;
+        minor_version = PyLong_AsLong(py_minor_version);
+        Py_DECREF(py_minor_version);
+        if (minor_version == -1 && PyErr_Occurred()) goto end;
+        #endif
+        if (!(types_module = PyImport_ImportModule("types"))) goto end;
+        if (!(code_type = PyObject_GetAttrString(types_module, "CodeType"))) goto end;
+        if (minor_version <= 7) {
+            (void)p;
+            result = PyObject_CallFunction(code_type, "iiiiiOOOOOOiOOO", a, k, l, s, f, code,
+                          c, n, v, fn, name, fline, lnos, fv, cell);
+        } else if (minor_version <= 10) {
+            result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOiOOO", a,p, k, l, s, f, code,
+                          c, n, v, fn, name, fline, lnos, fv, cell);
         } else {
-            *t->p = PyString_FromStringAndSize(t->s, t->n - 1);
+            if (!(exception_table = PyBytes_FromStringAndSize(NULL, 0))) goto end;
+            result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOOiOOOO", a,p, k, l, s, f, code,
+                          c, n, v, fn, name, name, fline, lnos, exception_table, fv, cell);
         }
-        #else
-        if (t->is_unicode | t->is_str) {
+    end:
+        Py_XDECREF(code_type);
+        Py_XDECREF(exception_table);
+        Py_XDECREF(types_module);
+        if (type) {
+            PyErr_Restore(type, value, traceback);
+        }
+        return result;
+    }
+#elif PY_VERSION_HEX >= 0x030B0000
+  static PyCodeObject* __Pyx__PyCode_New(int a, int p, int k, int l, int s, int f,
+                                         PyObject *code, PyObject *c, PyObject* n, PyObject *v,
+                                         PyObject *fv, PyObject *cell, PyObject* fn,
+                                         PyObject *name, int fline, PyObject *lnos) {
+    PyCodeObject *result;
+    result =
+      #if PY_VERSION_HEX >= 0x030C0000
+        PyUnstable_Code_NewWithPosOnlyArgs
+      #else
+        PyCode_NewWithPosOnlyArgs
+      #endif
+        (a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, name, fline, lnos, __pyx_mstate_global->__pyx_empty_bytes);
+    #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030c00A1
+    if (likely(result))
+        result->_co_firsttraceable = 0;
+    #endif
+    return result;
+  }
+#elif PY_VERSION_HEX >= 0x030800B2 && !CYTHON_COMPILING_IN_PYPY
+  #define __Pyx__PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
+          PyCode_NewWithPosOnlyArgs(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
+#else
+  #define __Pyx__PyCode_New(a, p, 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)
+#endif
+static PyObject* __Pyx_PyCode_New(
+        const __Pyx_PyCode_New_function_description descr,
+        PyObject * const *varnames,
+        PyObject *filename,
+        PyObject *funcname,
+        const char *line_table,
+        PyObject *tuple_dedup_map
+) {
+    PyObject *code_obj = NULL, *varnames_tuple_dedup = NULL, *code_bytes = NULL, *line_table_bytes = NULL;
+    Py_ssize_t var_count = (Py_ssize_t) descr.nlocals;
+    PyObject *varnames_tuple = PyTuple_New(var_count);
+    if (unlikely(!varnames_tuple)) return NULL;
+    for (Py_ssize_t i=0; i < var_count; i++) {
+        Py_INCREF(varnames[i]);
+        if (__Pyx_PyTuple_SET_ITEM(varnames_tuple, i, varnames[i]) != (0)) goto done;
+    }
+    #if CYTHON_COMPILING_IN_LIMITED_API
+    varnames_tuple_dedup = PyDict_GetItem(tuple_dedup_map, varnames_tuple);
+    if (!varnames_tuple_dedup) {
+        if (unlikely(PyDict_SetItem(tuple_dedup_map, varnames_tuple, varnames_tuple) < 0)) goto done;
+        varnames_tuple_dedup = varnames_tuple;
+    }
+    #else
+    varnames_tuple_dedup = PyDict_SetDefault(tuple_dedup_map, varnames_tuple, varnames_tuple);
+    if (unlikely(!varnames_tuple_dedup)) goto done;
+    #endif
+    #if CYTHON_AVOID_BORROWED_REFS
+    Py_INCREF(varnames_tuple_dedup);
+    #endif
+    if (__PYX_LIMITED_VERSION_HEX >= (0x030b0000) && line_table != NULL
+        && !CYTHON_COMPILING_IN_GRAAL) {
+        line_table_bytes = PyBytes_FromStringAndSize(line_table, descr.line_table_length);
+        if (unlikely(!line_table_bytes)) goto done;
+        Py_ssize_t code_len = (descr.line_table_length * 2 + 4) & ~3;
+        code_bytes = PyBytes_FromStringAndSize(NULL, code_len);
+        if (unlikely(!code_bytes)) goto done;
+        char* c_code_bytes = PyBytes_AsString(code_bytes);
+        if (unlikely(!c_code_bytes)) goto done;
+        memset(c_code_bytes, 0, (size_t) code_len);
+    }
+    code_obj = (PyObject*) __Pyx__PyCode_New(
+        (int) descr.argcount,
+        (int) descr.num_posonly_args,
+        (int) descr.num_kwonly_args,
+        (int) descr.nlocals,
+        0,
+        (int) descr.flags,
+        code_bytes ? code_bytes : __pyx_mstate_global->__pyx_empty_bytes,
+        __pyx_mstate_global->__pyx_empty_tuple,
+        __pyx_mstate_global->__pyx_empty_tuple,
+        varnames_tuple_dedup,
+        __pyx_mstate_global->__pyx_empty_tuple,
+        __pyx_mstate_global->__pyx_empty_tuple,
+        filename,
+        funcname,
+        (int) descr.first_line,
+        (__PYX_LIMITED_VERSION_HEX >= (0x030b0000) && line_table_bytes) ? line_table_bytes : __pyx_mstate_global->__pyx_empty_bytes
+    );
+done:
+    Py_XDECREF(code_bytes);
+    Py_XDECREF(line_table_bytes);
+    #if CYTHON_AVOID_BORROWED_REFS
+    Py_XDECREF(varnames_tuple_dedup);
+    #endif
+    Py_DECREF(varnames_tuple);
+    return code_obj;
+}
+
+/* InitStrings */
+static int __Pyx_InitStrings(__Pyx_StringTabEntry const *t, PyObject **target, const char* const* encoding_names) {
+    while (t->s) {
+        PyObject *str;
+        if (t->is_unicode) {
             if (t->intern) {
-                *t->p = PyUnicode_InternFromString(t->s);
+                str = PyUnicode_InternFromString(t->s);
             } else if (t->encoding) {
-                *t->p = PyUnicode_Decode(t->s, t->n - 1, t->encoding, NULL);
+                str = PyUnicode_Decode(t->s, t->n - 1, encoding_names[t->encoding], NULL);
             } else {
-                *t->p = PyUnicode_FromStringAndSize(t->s, t->n - 1);
+                str = PyUnicode_FromStringAndSize(t->s, t->n - 1);
             }
         } else {
-            *t->p = PyBytes_FromStringAndSize(t->s, t->n - 1);
+            str = PyBytes_FromStringAndSize(t->s, t->n - 1);
         }
-        #endif
-        if (!*t->p)
+        if (!str)
             return -1;
-        if (PyObject_Hash(*t->p) == -1)
+        *target = str;
+        if (PyObject_Hash(str) == -1)
             return -1;
         ++t;
+        ++target;
     }
     return 0;
 }
 
+#include <string.h>
+static CYTHON_INLINE Py_ssize_t __Pyx_ssize_strlen(const char *s) {
+    size_t len = strlen(s);
+    if (unlikely(len > (size_t) PY_SSIZE_T_MAX)) {
+        PyErr_SetString(PyExc_OverflowError, "byte string is too long");
+        return -1;
+    }
+    return (Py_ssize_t) len;
+}
 static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) {
-    return __Pyx_PyUnicode_FromStringAndSize(c_str, (Py_ssize_t)strlen(c_str));
+    Py_ssize_t len = __Pyx_ssize_strlen(c_str);
+    if (unlikely(len < 0)) return NULL;
+    return __Pyx_PyUnicode_FromStringAndSize(c_str, len);
+}
+static CYTHON_INLINE PyObject* __Pyx_PyByteArray_FromString(const char* c_str) {
+    Py_ssize_t len = __Pyx_ssize_strlen(c_str);
+    if (unlikely(len < 0)) return NULL;
+    return PyByteArray_FromStringAndSize(c_str, len);
 }
 static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject* o) {
     Py_ssize_t ignore;
     return __Pyx_PyObject_AsStringAndSize(o, &ignore);
 }
-#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT
-#if !CYTHON_PEP393_ENABLED
-static const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) {
-    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
+#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_UTF8
+static CYTHON_INLINE const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) {
+    if (unlikely(__Pyx_PyUnicode_READY(o) == -1)) return NULL;
+#if CYTHON_COMPILING_IN_LIMITED_API
     {
-        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;
-            }
+        const char* result;
+        Py_ssize_t unicode_length;
+        CYTHON_MAYBE_UNUSED_VAR(unicode_length); // only for __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
+        #if __PYX_LIMITED_VERSION_HEX < 0x030A0000
+        if (unlikely(PyArg_Parse(o, "s#", &result, length) < 0)) return NULL;
+        #else
+        result = PyUnicode_AsUTF8AndSize(o, length);
+        #endif
+        #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
+        unicode_length = PyUnicode_GetLength(o);
+        if (unlikely(unicode_length < 0)) return NULL;
+        if (unlikely(unicode_length != *length)) {
+            PyUnicode_AsASCIIString(o);
+            return NULL;
         }
+        #endif
+        return result;
     }
-#endif
-    *length = PyBytes_GET_SIZE(defenc);
-    return defenc_c;
-}
 #else
-static CYTHON_INLINE const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) {
-    if (unlikely(__Pyx_PyUnicode_READY(o) == -1)) return NULL;
 #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
     if (likely(PyUnicode_IS_ASCII(o))) {
         *length = PyUnicode_GET_LENGTH(o);
@@ -75604,25 +98701,25 @@ static CYTHON_INLINE const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py
 #else
     return PyUnicode_AsUTF8AndSize(o, length);
 #endif
-}
 #endif
+}
 #endif
 static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ssize_t *length) {
-#if __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 __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_UTF8
+    if (PyUnicode_Check(o)) {
         return __Pyx_PyUnicode_AsStringAndSize(o, length);
     } else
 #endif
-#if (!CYTHON_COMPILING_IN_PYPY) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE))
     if (PyByteArray_Check(o)) {
+#if (CYTHON_ASSUME_SAFE_SIZE && CYTHON_ASSUME_SAFE_MACROS) || (CYTHON_COMPILING_IN_PYPY && (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE)))
         *length = PyByteArray_GET_SIZE(o);
         return PyByteArray_AS_STRING(o);
-    } else
+#else
+        *length = PyByteArray_Size(o);
+        if (*length == -1) return NULL;
+        return PyByteArray_AsString(o);
 #endif
+    } else
     {
         char* result;
         int r = PyBytes_AsStringAndSize(o, &result, length);
@@ -75645,95 +98742,66 @@ static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject* x) {
     Py_DECREF(x);
     return retval;
 }
-static PyObject* __Pyx_PyNumber_IntOrLongWrongResultType(PyObject* result, const char* type_name) {
-#if PY_MAJOR_VERSION >= 3
+static PyObject* __Pyx_PyNumber_LongWrongResultType(PyObject* result) {
+    __Pyx_TypeName result_type_name = __Pyx_PyType_GetFullyQualifiedName(Py_TYPE(result));
     if (PyLong_Check(result)) {
         if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1,
-                "__int__ returned non-int (type %.200s).  "
-                "The ability to return an instance of a strict subclass of int "
-                "is deprecated, and may be removed in a future version of Python.",
-                Py_TYPE(result)->tp_name)) {
+                "__int__ returned non-int (type " __Pyx_FMT_TYPENAME ").  "
+                "The ability to return an instance of a strict subclass of int is deprecated, "
+                "and may be removed in a future version of Python.",
+                result_type_name)) {
+            __Pyx_DECREF_TypeName(result_type_name);
             Py_DECREF(result);
             return NULL;
         }
+        __Pyx_DECREF_TypeName(result_type_name);
         return result;
     }
-#endif
     PyErr_Format(PyExc_TypeError,
-                 "__%.4s__ returned non-%.4s (type %.200s)",
-                 type_name, type_name, Py_TYPE(result)->tp_name);
+                 "__int__ returned non-int (type " __Pyx_FMT_TYPENAME ")",
+                 result_type_name);
+    __Pyx_DECREF_TypeName(result_type_name);
     Py_DECREF(result);
     return NULL;
 }
-static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x) {
+static CYTHON_INLINE PyObject* __Pyx_PyNumber_Long(PyObject* x) {
 #if CYTHON_USE_TYPE_SLOTS
   PyNumberMethods *m;
 #endif
-  const char *name = NULL;
   PyObject *res = NULL;
-#if PY_MAJOR_VERSION < 3
-  if (likely(PyInt_Check(x) || PyLong_Check(x)))
-#else
   if (likely(PyLong_Check(x)))
-#endif
-    return __Pyx_NewRef(x);
+      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 = m->nb_int(x);
-  }
-  else if (m && m->nb_long) {
-    name = "long";
-    res = m->nb_long(x);
-  }
-  #else
   if (likely(m && m->nb_int)) {
-    name = "int";
-    res = m->nb_int(x);
+      res = m->nb_int(x);
   }
-  #endif
 #else
   if (!PyBytes_CheckExact(x) && !PyUnicode_CheckExact(x)) {
-    res = PyNumber_Int(x);
+      res = PyNumber_Long(x);
   }
 #endif
   if (likely(res)) {
-#if PY_MAJOR_VERSION < 3
-    if (unlikely(!PyInt_Check(res) && !PyLong_Check(res))) {
-#else
-    if (unlikely(!PyLong_CheckExact(res))) {
-#endif
-        return __Pyx_PyNumber_IntOrLongWrongResultType(res, name);
-    }
+      if (unlikely(!PyLong_CheckExact(res))) {
+          return __Pyx_PyNumber_LongWrongResultType(res);
+      }
   }
   else if (!PyErr_Occurred()) {
-    PyErr_SetString(PyExc_TypeError,
-                    "an integer is required");
+      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(b);
-  }
-#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;
+    if (likely(__Pyx_PyLong_IsCompact(b))) {
+        return __Pyx_PyLong_CompactValue(b);
     } else {
+      const digit* digits = __Pyx_PyLong_Digits(b);
+      const Py_ssize_t size = __Pyx_PyLong_SignedDigitCount(b);
       switch (size) {
          case 2:
            if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) {
@@ -75772,16 +98840,367 @@ static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) {
   }
   x = PyNumber_Index(b);
   if (!x) return -1;
-  ival = PyInt_AsSsize_t(x);
+  ival = PyLong_AsSsize_t(x);
   Py_DECREF(x);
   return ival;
 }
+static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject* o) {
+  if (sizeof(Py_hash_t) == sizeof(Py_ssize_t)) {
+    return (Py_hash_t) __Pyx_PyIndex_AsSsize_t(o);
+  } else {
+    Py_ssize_t ival;
+    PyObject *x;
+    x = PyNumber_Index(o);
+    if (!x) return -1;
+    ival = PyLong_AsLong(x);
+    Py_DECREF(x);
+    return ival;
+  }
+}
+static CYTHON_INLINE PyObject *__Pyx_Owned_Py_None(int b) {
+    CYTHON_UNUSED_VAR(b);
+    return __Pyx_NewRef(Py_None);
+}
 static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b) {
   return b ? __Pyx_NewRef(Py_True) : __Pyx_NewRef(Py_False);
 }
-static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) {
-    return PyInt_FromSize_t(ival);
+static CYTHON_INLINE PyObject * __Pyx_PyLong_FromSize_t(size_t ival) {
+    return PyLong_FromSize_t(ival);
+}
+#if CYTHON_USE_PYLONG_INTERNALS
+static CYTHON_INLINE int __Pyx_PyLong_CompactAsLong(PyObject *x, long *return_value) {
+    if (unlikely(!__Pyx_PyLong_IsCompact(x)))
+        return 0;
+    Py_ssize_t value = __Pyx_PyLong_CompactValue(x);
+    if ((sizeof(long) < sizeof(Py_ssize_t)) && unlikely(value != (long) value))
+        return 0;
+    *return_value = (long) value;
+    return 1;
+}
+#endif
+
+
+/* MultiPhaseInitModuleState */
+#if CYTHON_PEP489_MULTI_PHASE_INIT && CYTHON_USE_MODULE_STATE
+#ifndef CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE
+#if (CYTHON_COMPILING_IN_LIMITED_API || PY_VERSION_HEX >= 0x030C0000)
+  #define CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE 1
+#else
+  #define CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE 0
+#endif
+#endif
+#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE && !CYTHON_ATOMICS
+#error "Module state with PEP489 requires atomics. Currently that's one of\
+ C11, C++11, gcc atomic intrinsics or MSVC atomic intrinsics"
+#endif
+#if !CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE
+#define __Pyx_ModuleStateLookup_Lock()
+#define __Pyx_ModuleStateLookup_Unlock()
+#elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d0000
+static PyMutex __Pyx_ModuleStateLookup_mutex = {0};
+#define __Pyx_ModuleStateLookup_Lock() PyMutex_Lock(&__Pyx_ModuleStateLookup_mutex)
+#define __Pyx_ModuleStateLookup_Unlock() PyMutex_Unlock(&__Pyx_ModuleStateLookup_mutex)
+#elif defined(__cplusplus) && __cplusplus >= 201103L
+#include <mutex>
+static std::mutex __Pyx_ModuleStateLookup_mutex;
+#define __Pyx_ModuleStateLookup_Lock() __Pyx_ModuleStateLookup_mutex.lock()
+#define __Pyx_ModuleStateLookup_Unlock() __Pyx_ModuleStateLookup_mutex.unlock()
+#elif defined(__STDC_VERSION__) && (__STDC_VERSION__ > 201112L) && !defined(__STDC_NO_THREADS__)
+#include <threads.h>
+static mtx_t __Pyx_ModuleStateLookup_mutex;
+static once_flag __Pyx_ModuleStateLookup_mutex_once_flag = ONCE_FLAG_INIT;
+static void __Pyx_ModuleStateLookup_initialize_mutex(void) {
+    mtx_init(&__Pyx_ModuleStateLookup_mutex, mtx_plain);
+}
+#define __Pyx_ModuleStateLookup_Lock()\
+  call_once(&__Pyx_ModuleStateLookup_mutex_once_flag, __Pyx_ModuleStateLookup_initialize_mutex);\
+  mtx_lock(&__Pyx_ModuleStateLookup_mutex)
+#define __Pyx_ModuleStateLookup_Unlock() mtx_unlock(&__Pyx_ModuleStateLookup_mutex)
+#elif defined(HAVE_PTHREAD_H)
+#include <pthread.h>
+static pthread_mutex_t __Pyx_ModuleStateLookup_mutex = PTHREAD_MUTEX_INITIALIZER;
+#define __Pyx_ModuleStateLookup_Lock() pthread_mutex_lock(&__Pyx_ModuleStateLookup_mutex)
+#define __Pyx_ModuleStateLookup_Unlock() pthread_mutex_unlock(&__Pyx_ModuleStateLookup_mutex)
+#elif defined(_WIN32)
+#include <Windows.h>  // synchapi.h on its own doesn't work
+static SRWLOCK __Pyx_ModuleStateLookup_mutex = SRWLOCK_INIT;
+#define __Pyx_ModuleStateLookup_Lock() AcquireSRWLockExclusive(&__Pyx_ModuleStateLookup_mutex)
+#define __Pyx_ModuleStateLookup_Unlock() ReleaseSRWLockExclusive(&__Pyx_ModuleStateLookup_mutex)
+#else
+#error "No suitable lock available for CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE.\
+ Requires C standard >= C11, or C++ standard >= C++11,\
+ or pthreads, or the Windows 32 API, or Python >= 3.13."
+#endif
+typedef struct {
+    int64_t id;
+    PyObject *module;
+} __Pyx_InterpreterIdAndModule;
+typedef struct {
+    char interpreter_id_as_index;
+    Py_ssize_t count;
+    Py_ssize_t allocated;
+    __Pyx_InterpreterIdAndModule table[1];
+} __Pyx_ModuleStateLookupData;
+#define __PYX_MODULE_STATE_LOOKUP_SMALL_SIZE 32
+#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE
+static __pyx_atomic_int_type __Pyx_ModuleStateLookup_read_counter = 0;
+#endif
+#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE
+static __pyx_atomic_ptr_type __Pyx_ModuleStateLookup_data = 0;
+#else
+static __Pyx_ModuleStateLookupData* __Pyx_ModuleStateLookup_data = NULL;
+#endif
+static __Pyx_InterpreterIdAndModule* __Pyx_State_FindModuleStateLookupTableLowerBound(
+        __Pyx_InterpreterIdAndModule* table,
+        Py_ssize_t count,
+        int64_t interpreterId) {
+    __Pyx_InterpreterIdAndModule* begin = table;
+    __Pyx_InterpreterIdAndModule* end = begin + count;
+    if (begin->id == interpreterId) {
+        return begin;
+    }
+    while ((end - begin) > __PYX_MODULE_STATE_LOOKUP_SMALL_SIZE) {
+        __Pyx_InterpreterIdAndModule* halfway = begin + (end - begin)/2;
+        if (halfway->id == interpreterId) {
+            return halfway;
+        }
+        if (halfway->id < interpreterId) {
+            begin = halfway;
+        } else {
+            end = halfway;
+        }
+    }
+    for (; begin < end; ++begin) {
+        if (begin->id >= interpreterId) return begin;
+    }
+    return begin;
+}
+static PyObject *__Pyx_State_FindModule(CYTHON_UNUSED void* dummy) {
+    int64_t interpreter_id = PyInterpreterState_GetID(__Pyx_PyInterpreterState_Get());
+    if (interpreter_id == -1) return NULL;
+#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE
+    __Pyx_ModuleStateLookupData* data = (__Pyx_ModuleStateLookupData*)__pyx_atomic_pointer_load_relaxed(&__Pyx_ModuleStateLookup_data);
+    {
+        __pyx_atomic_incr_acq_rel(&__Pyx_ModuleStateLookup_read_counter);
+        if (likely(data)) {
+            __Pyx_ModuleStateLookupData* new_data = (__Pyx_ModuleStateLookupData*)__pyx_atomic_pointer_load_acquire(&__Pyx_ModuleStateLookup_data);
+            if (likely(data == new_data)) {
+                goto read_finished;
+            }
+        }
+        __pyx_atomic_decr_acq_rel(&__Pyx_ModuleStateLookup_read_counter);
+        __Pyx_ModuleStateLookup_Lock();
+        __pyx_atomic_incr_relaxed(&__Pyx_ModuleStateLookup_read_counter);
+        data = (__Pyx_ModuleStateLookupData*)__pyx_atomic_pointer_load_relaxed(&__Pyx_ModuleStateLookup_data);
+        __Pyx_ModuleStateLookup_Unlock();
+    }
+  read_finished:;
+#else
+    __Pyx_ModuleStateLookupData* data = __Pyx_ModuleStateLookup_data;
+#endif
+    __Pyx_InterpreterIdAndModule* found = NULL;
+    if (unlikely(!data)) goto end;
+    if (data->interpreter_id_as_index) {
+        if (interpreter_id < data->count) {
+            found = data->table+interpreter_id;
+        }
+    } else {
+        found = __Pyx_State_FindModuleStateLookupTableLowerBound(
+            data->table, data->count, interpreter_id);
+    }
+  end:
+    {
+        PyObject *result=NULL;
+        if (found && found->id == interpreter_id) {
+            result = found->module;
+        }
+#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE
+        __pyx_atomic_decr_acq_rel(&__Pyx_ModuleStateLookup_read_counter);
+#endif
+        return result;
+    }
+}
+#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE
+static void __Pyx_ModuleStateLookup_wait_until_no_readers(void) {
+    while (__pyx_atomic_load(&__Pyx_ModuleStateLookup_read_counter) != 0);
+}
+#else
+#define __Pyx_ModuleStateLookup_wait_until_no_readers()
+#endif
+static int __Pyx_State_AddModuleInterpIdAsIndex(__Pyx_ModuleStateLookupData **old_data, PyObject* module, int64_t interpreter_id) {
+    Py_ssize_t to_allocate = (*old_data)->allocated;
+    while (to_allocate <= interpreter_id) {
+        if (to_allocate == 0) to_allocate = 1;
+        else to_allocate *= 2;
+    }
+    __Pyx_ModuleStateLookupData *new_data = *old_data;
+    if (to_allocate != (*old_data)->allocated) {
+         new_data = (__Pyx_ModuleStateLookupData *)realloc(
+            *old_data,
+            sizeof(__Pyx_ModuleStateLookupData)+(to_allocate-1)*sizeof(__Pyx_InterpreterIdAndModule));
+        if (!new_data) {
+            PyErr_NoMemory();
+            return -1;
+        }
+        for (Py_ssize_t i = new_data->allocated; i < to_allocate; ++i) {
+            new_data->table[i].id = i;
+            new_data->table[i].module = NULL;
+        }
+        new_data->allocated = to_allocate;
+    }
+    new_data->table[interpreter_id].module = module;
+    if (new_data->count < interpreter_id+1) {
+        new_data->count = interpreter_id+1;
+    }
+    *old_data = new_data;
+    return 0;
+}
+static void __Pyx_State_ConvertFromInterpIdAsIndex(__Pyx_ModuleStateLookupData *data) {
+    __Pyx_InterpreterIdAndModule *read = data->table;
+    __Pyx_InterpreterIdAndModule *write = data->table;
+    __Pyx_InterpreterIdAndModule *end = read + data->count;
+    for (; read<end; ++read) {
+        if (read->module) {
+            write->id = read->id;
+            write->module = read->module;
+            ++write;
+        }
+    }
+    data->count = write - data->table;
+    for (; write<end; ++write) {
+        write->id = 0;
+        write->module = NULL;
+    }
+    data->interpreter_id_as_index = 0;
+}
+static int __Pyx_State_AddModule(PyObject* module, CYTHON_UNUSED void* dummy) {
+    int64_t interpreter_id = PyInterpreterState_GetID(__Pyx_PyInterpreterState_Get());
+    if (interpreter_id == -1) return -1;
+    int result = 0;
+    __Pyx_ModuleStateLookup_Lock();
+#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE
+    __Pyx_ModuleStateLookupData *old_data = (__Pyx_ModuleStateLookupData *)
+            __pyx_atomic_pointer_exchange(&__Pyx_ModuleStateLookup_data, 0);
+#else
+    __Pyx_ModuleStateLookupData *old_data = __Pyx_ModuleStateLookup_data;
+#endif
+    __Pyx_ModuleStateLookupData *new_data = old_data;
+    if (!new_data) {
+        new_data = (__Pyx_ModuleStateLookupData *)calloc(1, sizeof(__Pyx_ModuleStateLookupData));
+        if (!new_data) {
+            result = -1;
+            PyErr_NoMemory();
+            goto end;
+        }
+        new_data->allocated = 1;
+        new_data->interpreter_id_as_index = 1;
+    }
+    __Pyx_ModuleStateLookup_wait_until_no_readers();
+    if (new_data->interpreter_id_as_index) {
+        if (interpreter_id < __PYX_MODULE_STATE_LOOKUP_SMALL_SIZE) {
+            result = __Pyx_State_AddModuleInterpIdAsIndex(&new_data, module, interpreter_id);
+            goto end;
+        }
+        __Pyx_State_ConvertFromInterpIdAsIndex(new_data);
+    }
+    {
+        Py_ssize_t insert_at = 0;
+        {
+            __Pyx_InterpreterIdAndModule* lower_bound = __Pyx_State_FindModuleStateLookupTableLowerBound(
+                new_data->table, new_data->count, interpreter_id);
+            assert(lower_bound);
+            insert_at = lower_bound - new_data->table;
+            if (unlikely(insert_at < new_data->count && lower_bound->id == interpreter_id)) {
+                lower_bound->module = module;
+                goto end;  // already in table, nothing more to do
+            }
+        }
+        if (new_data->count+1 >= new_data->allocated) {
+            Py_ssize_t to_allocate = (new_data->count+1)*2;
+            new_data =
+                (__Pyx_ModuleStateLookupData*)realloc(
+                    new_data,
+                    sizeof(__Pyx_ModuleStateLookupData) +
+                    (to_allocate-1)*sizeof(__Pyx_InterpreterIdAndModule));
+            if (!new_data) {
+                result = -1;
+                new_data = old_data;
+                PyErr_NoMemory();
+                goto end;
+            }
+            new_data->allocated = to_allocate;
+        }
+        ++new_data->count;
+        int64_t last_id = interpreter_id;
+        PyObject *last_module = module;
+        for (Py_ssize_t i=insert_at; i<new_data->count; ++i) {
+            int64_t current_id = new_data->table[i].id;
+            new_data->table[i].id = last_id;
+            last_id = current_id;
+            PyObject *current_module = new_data->table[i].module;
+            new_data->table[i].module = last_module;
+            last_module = current_module;
+        }
+    }
+  end:
+#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE
+    __pyx_atomic_pointer_exchange(&__Pyx_ModuleStateLookup_data, new_data);
+#else
+    __Pyx_ModuleStateLookup_data = new_data;
+#endif
+    __Pyx_ModuleStateLookup_Unlock();
+    return result;
+}
+static int __Pyx_State_RemoveModule(CYTHON_UNUSED void* dummy) {
+    int64_t interpreter_id = PyInterpreterState_GetID(__Pyx_PyInterpreterState_Get());
+    if (interpreter_id == -1) return -1;
+    __Pyx_ModuleStateLookup_Lock();
+#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE
+    __Pyx_ModuleStateLookupData *data = (__Pyx_ModuleStateLookupData *)
+            __pyx_atomic_pointer_exchange(&__Pyx_ModuleStateLookup_data, 0);
+#else
+    __Pyx_ModuleStateLookupData *data = __Pyx_ModuleStateLookup_data;
+#endif
+    if (data->interpreter_id_as_index) {
+        if (interpreter_id < data->count) {
+            data->table[interpreter_id].module = NULL;
+        }
+        goto done;
+    }
+    {
+        __Pyx_ModuleStateLookup_wait_until_no_readers();
+        __Pyx_InterpreterIdAndModule* lower_bound = __Pyx_State_FindModuleStateLookupTableLowerBound(
+            data->table, data->count, interpreter_id);
+        if (!lower_bound) goto done;
+        if (lower_bound->id != interpreter_id) goto done;
+        __Pyx_InterpreterIdAndModule *end = data->table+data->count;
+        for (;lower_bound<end-1; ++lower_bound) {
+            lower_bound->id = (lower_bound+1)->id;
+            lower_bound->module = (lower_bound+1)->module;
+        }
+    }
+    --data->count;
+    if (data->count == 0) {
+        free(data);
+        data = NULL;
+    }
+  done:
+#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE
+    __pyx_atomic_pointer_exchange(&__Pyx_ModuleStateLookup_data, data);
+#else
+    __Pyx_ModuleStateLookup_data = data;
+#endif
+    __Pyx_ModuleStateLookup_Unlock();
+    return 0;
 }
+#endif
+
+/* #### Code section: utility_code_pragmas_end ### */
+#ifdef _MSC_VER
+#pragma warning( pop )
+#endif
+
 
 
+/* #### Code section: end ### */
 #endif /* Py_PYTHON_H */
diff --git a/talib/_ta_lib.pxd b/talib/_ta_lib.pxd
index c9530958f..65b712177 100644
--- a/talib/_ta_lib.pxd
+++ b/talib/_ta_lib.pxd
@@ -1,3 +1,4 @@
+#cython: language_level=2
 
 cdef extern from "ta-lib/ta_defs.h":
 
@@ -84,24 +85,24 @@ cdef extern from "ta-lib/ta_defs.h":
     TA_CandleSettingType TA_AllCandleSettings = 11
 
 cdef extern from "ta-lib/ta_common.h":
-    char *TA_GetVersionString()
-    char *TA_GetVersionMajor()
-    char *TA_GetVersionMinor()
-    char *TA_GetVersionBuild()
-    char *TA_GetVersionDate()
-    char *TA_GetVersionTime()
+    const char *TA_GetVersionString()
+    const char *TA_GetVersionMajor()
+    const char *TA_GetVersionMinor()
+    const char *TA_GetVersionBuild()
+    const char *TA_GetVersionDate()
+    const char *TA_GetVersionTime()
 
     ctypedef double TA_Real
     ctypedef int TA_Integer
 
     ctypedef struct TA_StringTable:
         unsigned int size
-        char **string
+        const char **string
         void *hiddenData
 
     ctypedef struct TA_RetCodeInfo:
-        char* enumStr
-        char* infoStr
+        const char* enumStr
+        const char* infoStr
 
     void TA_SetRetCodeInfo(TA_RetCode theRetCode, TA_RetCodeInfo *retCodeInfo)
 
@@ -113,25 +114,25 @@ cdef extern from "ta-lib/ta_abstract.h":
     TA_RetCode TA_GroupTableAlloc(TA_StringTable **table)
     TA_RetCode TA_GroupTableFree(TA_StringTable *table)
 
-    TA_RetCode TA_FuncTableAlloc(char *group, TA_StringTable **table)
+    TA_RetCode TA_FuncTableAlloc(const char *group, TA_StringTable **table)
     TA_RetCode TA_FuncTableFree(TA_StringTable *table)
 
     ctypedef unsigned int TA_FuncHandle
-    TA_RetCode TA_GetFuncHandle(char *name, TA_FuncHandle **handle)
+    TA_RetCode TA_GetFuncHandle(const char *name, const TA_FuncHandle **handle)
 
     ctypedef int TA_FuncFlags
     ctypedef struct TA_FuncInfo:
-        char *name
-        char *group
-        char *hint
-        char *camelCaseName
+        const char *name
+        const char *group
+        const char *hint
+        const char *camelCaseName
         TA_FuncFlags flags
         unsigned int nbInput
         unsigned int nbOptInput
         unsigned int nbOutput
-        TA_FuncHandle *handle
+        const TA_FuncHandle *handle
 
-    TA_RetCode TA_GetFuncInfo(TA_FuncHandle *handle, TA_FuncInfo **funcInfo)
+    TA_RetCode TA_GetFuncInfo(const TA_FuncHandle *handle, const TA_FuncInfo **funcInfo)
 
     ctypedef int TA_InputParameterType
     TA_InputParameterType TA_Input_Price = 0
@@ -154,44 +155,46 @@ cdef extern from "ta-lib/ta_abstract.h":
 
     ctypedef struct TA_InputParameterInfo:
         TA_InputParameterType type
-        char *paramName
+        const char *paramName
         TA_InputFlags flags
 
     ctypedef struct TA_OptInputParameterInfo:
         TA_OptInputParameterType type
-        char *paramName
+        const char *paramName
         TA_OptInputFlags flags
-        char *displayName
-        void *dataSet
+        const char *displayName
+        const void *dataSet
         TA_Real defaultValue
-        char *hint
-        char *helpFile
+        const char *hint
+        const char *helpFile
 
     ctypedef struct TA_OutputParameterInfo:
         TA_OutputParameterType type
-        char *paramName
+        const char *paramName
         TA_OutputFlags flags
 
-    TA_RetCode TA_GetInputParameterInfo(TA_FuncHandle *handle, unsigned int paramIndex, TA_InputParameterInfo **info)
-    TA_RetCode TA_GetOptInputParameterInfo(TA_FuncHandle *handle, unsigned int paramIndex, TA_OptInputParameterInfo **info)
-    TA_RetCode TA_GetOutputParameterInfo(TA_FuncHandle *handle, unsigned int paramIndex, TA_OutputParameterInfo **info)
+    TA_RetCode TA_GetInputParameterInfo(const TA_FuncHandle *handle, unsigned int paramIndex, const TA_InputParameterInfo **info)
+    TA_RetCode TA_GetOptInputParameterInfo(const TA_FuncHandle *handle, unsigned int paramIndex, const TA_OptInputParameterInfo **info)
+    TA_RetCode TA_GetOutputParameterInfo(const TA_FuncHandle *handle, unsigned int paramIndex, const TA_OutputParameterInfo **info)
 
     ctypedef struct TA_ParamHolder:
         void *hiddenData
 
-    TA_RetCode TA_ParamHolderAlloc(TA_FuncHandle *handle, TA_ParamHolder **allocatedParams) # get_lookback()
+    TA_RetCode TA_ParamHolderAlloc(const TA_FuncHandle *handle, TA_ParamHolder **allocatedParams) # get_lookback()
     TA_RetCode TA_ParamHolderFree(TA_ParamHolder *params)
 
     TA_RetCode TA_SetOptInputParamInteger(TA_ParamHolder *params, unsigned int paramIndex, TA_Integer optInValue)
     TA_RetCode TA_SetOptInputParamReal(TA_ParamHolder *params, unsigned int paramIndex, TA_Real optInValue)
 
-    TA_RetCode TA_GetLookback(TA_ParamHolder *params, TA_Integer *lookback)
+    TA_RetCode TA_GetLookback(const TA_ParamHolder *params, TA_Integer *lookback)
 
-    TA_RetCode TA_CallFunc(TA_ParamHolder *params, TA_Integer startIdx, TA_Integer endIdx, TA_Integer *outBegIdx, TA_Integer *outNbElement)
+    TA_RetCode TA_CallFunc(const TA_ParamHolder *params, TA_Integer startIdx, TA_Integer endIdx, TA_Integer *outBegIdx, TA_Integer *outNbElement)
 
     char* TA_FunctionDescriptionXML()
 
 cdef extern from "ta-lib/ta_func.h":
+    TA_RetCode TA_ACCBANDS(int startIdx, int endIdx, const double inHigh[], const double inLow[], const double inClose[], int optInTimePeriod, int *outBegIdx, int *outNBElement, double outRealUpperBand[], double outRealMiddleBand[], double outRealLowerBand[])
+    int TA_ACCBANDS_Lookback(int optInTimePeriod)
     TA_RetCode TA_ACOS(int startIdx, int endIdx, const double inReal[], int *outBegIdx, int *outNBElement, double outReal[])
     int TA_ACOS_Lookback()
     TA_RetCode TA_AD(int startIdx, int endIdx, const double inHigh[], const double inLow[], const double inClose[], const double inVolume[], int *outBegIdx, int *outNBElement, double outReal[])
@@ -218,6 +221,8 @@ cdef extern from "ta-lib/ta_func.h":
     int TA_ATR_Lookback(int optInTimePeriod)
     TA_RetCode TA_AVGPRICE(int startIdx, int endIdx, const double inOpen[], const double inHigh[], const double inLow[], const double inClose[], int *outBegIdx, int *outNBElement, double outReal[])
     int TA_AVGPRICE_Lookback()
+    TA_RetCode TA_AVGDEV(int startIdx, int endIdx, const double inReal[], int optInTimePeriod, int *outBegIdx, int *outNBElement, double outReal[])
+    int TA_AVGDEV_Lookback(int optInTimePeriod)
     TA_RetCode TA_BBANDS(int startIdx, int endIdx, const double inReal[], int optInTimePeriod, double optInNbDevUp, double optInNbDevDn, TA_MAType optInMAType, int *outBegIdx, int *outNBElement, double outRealUpperBand[], double outRealMiddleBand[], double outRealLowerBand[])
     int TA_BBANDS_Lookback(int optInTimePeriod, double optInNbDevUp, double optInNbDevDn, TA_MAType optInMAType)
     TA_RetCode TA_BETA(int startIdx, int endIdx, const double inReal0[], const double inReal1[], int optInTimePeriod, int *outBegIdx, int *outNBElement, double outReal[])
@@ -382,6 +387,8 @@ cdef extern from "ta-lib/ta_func.h":
     int TA_HT_TRENDLINE_Lookback()
     TA_RetCode TA_HT_TRENDMODE(int startIdx, int endIdx, const double inReal[], int *outBegIdx, int *outNBElement, int outInteger[])
     int TA_HT_TRENDMODE_Lookback()
+    TA_RetCode TA_IMI(int startIdx, int endIdx, const double inOpen[], const double inClose[], int optInTimePeriod, int *outBegIdx, int *outNBElement, double outReal[])
+    int TA_IMI_Lookback(int optInTimePeriod)
     TA_RetCode TA_KAMA(int startIdx, int endIdx, const double inReal[], int optInTimePeriod, int *outBegIdx, int *outNBElement, double outReal[])
     int TA_KAMA_Lookback(int optInTimePeriod)
     TA_RetCode TA_LINEARREG(int startIdx, int endIdx, const double inReal[], int optInTimePeriod, int *outBegIdx, int *outNBElement, double outReal[])
@@ -454,8 +461,8 @@ cdef extern from "ta-lib/ta_func.h":
     int TA_ROCR_Lookback(int optInTimePeriod)
     TA_RetCode TA_ROCR100(int startIdx, int endIdx, const double inReal[], int optInTimePeriod, int *outBegIdx, int *outNBElement, double outReal[])
     int TA_ROCR100_Lookback(int optInTimePeriod)
-    TA_RetCode TA_RSI(int startIdx, int endIdx, const double inReal[], int optInTimePeriod, int *outBegIdx, int *outNBElement, double outReal[])
-    int TA_RSI_Lookback(int optInTimePeriod)
+    TA_RetCode TA_RSI(int startIdx, int endIdx, const double inReal[], int optInTimePeriod, int *outBegIdx, int *outNBElement, double outReal[]) nogil
+    int TA_RSI_Lookback(int optInTimePeriod) nogil
     TA_RetCode TA_SAR(int startIdx, int endIdx, const double inHigh[], const double inLow[], double optInAcceleration, double optInMaximum, int *outBegIdx, int *outNBElement, double outReal[])
     int TA_SAR_Lookback(double optInAcceleration, double optInMaximum)
     TA_RetCode TA_SAREXT(int startIdx, int endIdx, const double inHigh[], const double inLow[], double optInStartValue, double optInOffsetOnReverse, double optInAccelerationInitLong, double optInAccelerationLong, double optInAccelerationMaxLong, double optInAccelerationInitShort, double optInAccelerationShort, double optInAccelerationMaxShort, int *outBegIdx, int *outNBElement, double outReal[])
diff --git a/talib/_ta_lib.pyi b/talib/_ta_lib.pyi
new file mode 100644
index 000000000..4356269ff
--- /dev/null
+++ b/talib/_ta_lib.pyi
@@ -0,0 +1,1983 @@
+import numpy as np
+from enum import Enum
+from typing import Tuple
+from numpy.typing import NDArray
+
+class MA_Type(Enum):
+    SMA = 0
+    EMA = 1
+    WMA = 2
+    DEMA = 3
+    TEMA = 4
+    TRIMA = 5
+    KAMA = 6
+    MAMA = 7
+    T3 = 8
+
+#Overlap Studies Functions
+
+def BBANDS(
+        real: NDArray[np.float64],  
+        timeperiod: int= 5, 
+        nbdevup: float= 2, 
+        nbdevdn: float= 2, 
+        matype: MA_Type = MA_Type.SMA
+        )-> Tuple[NDArray[np.float64], NDArray[np.float64], NDArray[np.float64]]: ...
+
+def DEMA(
+        real: NDArray[np.float64], 
+        timeperiod: int= 30
+        )-> NDArray[np.float64]: ...
+
+def EMA(
+        real: NDArray[np.float64], 
+        timeperiod: int= 30
+        )-> NDArray[np.float64]: ...
+
+def HT_TRENDLINE(real: NDArray[np.float64])-> NDArray[np.float64]: ...
+
+def KAMA(
+        real: NDArray[np.float64], 
+        timeperiod: int= 30
+        )-> NDArray[np.float64]: ...
+
+def MA(
+        real: NDArray[np.float64], 
+        timeperiod: int= 30,
+        matype: MA_Type = MA_Type.SMA
+        )-> NDArray[np.float64]: ...
+
+def MAMA(
+        real: NDArray[np.float64], 
+        fastlimit: float= 0, 
+        slowlimit: float= 0
+        )-> Tuple[NDArray[np.float64], NDArray[np.float64]]: ...
+
+def MAVP(
+        real: NDArray[np.float64], 
+        periods: float, 
+        minperiod: int= 2, 
+        maxperiod: int= 30, 
+        matype: MA_Type = MA_Type.SMA
+        )-> NDArray[np.float64]: ...
+
+def MIDPOINT(
+        real: NDArray[np.float64], 
+        timeperiod: int= 14
+        )-> NDArray[np.float64]: ...
+
+def MIDPRICE(
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        timeperiod: int= 14
+        )-> NDArray[np.float64]: ...
+
+def SAR(
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        acceleration: float= 0, 
+        maximum: float= 0
+        )-> NDArray[np.float64]: ...
+
+def SAREXT(
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        startvalue: float= 0, 
+        offsetonreverse: float= 0, 
+        accelerationinitlong: float= 0, 
+        accelerationlong: float= 0, 
+        accelerationmaxlong: float= 0, 
+        accelerationinitshort: float= 0, 
+        accelerationshort: float= 0, 
+        accelerationmaxshort: float= 0
+        )-> NDArray[np.float64]: ...
+
+def SMA(
+        real: NDArray[np.float64], 
+        timeperiod: int= 30
+        )-> NDArray[np.float64]: ...
+
+def T3(
+        real: NDArray[np.float64], 
+        timeperiod: int= 5, 
+        vfactor: float= 0
+        )-> NDArray[np.float64]: ...
+
+def TEMA(
+        real: NDArray[np.float64], 
+        timeperiod: int= 30
+        )-> NDArray[np.float64]: ...
+
+def TRIMA(
+        real: NDArray[np.float64], 
+        timeperiod: int= 30
+        )-> NDArray[np.float64]: ...
+
+def WMA(
+        real: NDArray[np.float64], 
+        timeperiod: int= 30
+        )-> NDArray[np.float64]: ...
+
+#Momentum Indicator Functions
+
+def ADX(
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64], 
+        timeperiod: int= 14
+        )-> NDArray[np.float64]: ...
+
+def ADXR(
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64], 
+        timeperiod: int= 14
+        )-> NDArray[np.float64]: ...
+
+def APO(
+        real: NDArray[np.float64], 
+        fastperiod: int= 12, 
+        slowperiod: int= 26, 
+        matype: MA_Type = MA_Type.SMA
+        )-> NDArray[np.float64]: ...
+
+def AROON(
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        timeperiod: int= 14
+        )-> Tuple[NDArray[np.float64], NDArray[np.float64]]: ...
+
+def AROONOSC(
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        timeperiod: int= 14
+        )-> NDArray[np.float64]: ...
+
+def BOP(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.float64]: ...
+
+def CCI(
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64], 
+        timeperiod: int= 14
+        )-> NDArray[np.float64]: ...
+
+def CMO(
+        real: NDArray[np.float64], 
+        timeperiod: int= 14
+        )-> NDArray[np.float64]: ...
+
+def DX(
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64], 
+        timeperiod: int= 14
+        )-> NDArray[np.float64]: ...
+
+def MACD(
+        real: NDArray[np.float64], 
+        fastperiod: int= 12, 
+        slowperiod: int= 26, 
+        signalperiod: int= 9
+        )-> Tuple[NDArray[np.float64], NDArray[np.float64], NDArray[np.float64]]: ...
+
+def MACDEXT(
+        real: NDArray[np.float64], 
+        fastperiod: int= 12, 
+        fastmatype: MA_Type = MA_Type.SMA, 
+        slowperiod: int= 26, 
+        slowmatype: MA_Type = MA_Type.SMA, 
+        signalperiod: int= 9, 
+        signalmatype: MA_Type = MA_Type.SMA
+        )-> Tuple[NDArray[np.float64], NDArray[np.float64], NDArray[np.float64]]: ...
+
+def MACDFIX(
+        real: NDArray[np.float64], 
+        signalperiod: int= 9
+        )-> Tuple[NDArray[np.float64], NDArray[np.float64], NDArray[np.float64]]: ...
+
+def MFI(
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64], 
+        volume: NDArray[np.float64], 
+        timeperiod: int= 14
+        )-> NDArray[np.float64]: ...
+
+def MINUS_DI(
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64], 
+        timeperiod: int= 14
+        )-> NDArray[np.float64]: ...
+
+def MINUS_DM(
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        timeperiod: int= 14
+        )-> NDArray[np.float64]: ...
+
+def MOM(
+        real: NDArray[np.float64], 
+        timeperiod: int= 10
+        )-> NDArray[np.float64]: ...
+
+def PLUS_DI(
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64], 
+        timeperiod: int= 14
+        )-> NDArray[np.float64]: ...
+
+def PLUS_DM(
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        timeperiod: int= 14
+        )-> NDArray[np.float64]: ...
+
+def PPO(
+        real: NDArray[np.float64], 
+        fastperiod: int= 12, 
+        slowperiod: int= 26, 
+        matype: MA_Type = MA_Type.SMA
+        )-> NDArray[np.float64]: ...
+
+def ROC(
+        real: NDArray[np.float64], 
+        timeperiod: int= 10
+        )-> NDArray[np.float64]: ...
+
+def ROCP(
+        real: NDArray[np.float64], 
+        timeperiod: int= 10
+        )-> NDArray[np.float64]: ...
+
+def ROCR(
+        real: NDArray[np.float64], 
+        timeperiod: int= 10
+        )-> NDArray[np.float64]: ...
+
+def ROCR100(
+        real: NDArray[np.float64], 
+        timeperiod: int= 10
+        )-> NDArray[np.float64]: ...
+
+def RSI(
+        real: NDArray[np.float64], 
+        timeperiod: int= 14
+        )-> NDArray[np.float64]: ...
+
+def STOCH(
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64], 
+        fastk_period: int= 5, 
+        slowk_period: int= 3, 
+        slowk_matype: MA_Type = MA_Type.SMA, 
+        slowd_period: int= 3, 
+        slowd_matype: MA_Type = MA_Type.SMA
+        )-> Tuple[NDArray[np.float64], NDArray[np.float64]]: ...
+
+def STOCHF(
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64], 
+        fastk_period: int= 5, 
+        fastd_period: int= 3, 
+        fastd_matype: MA_Type = MA_Type.SMA
+        )-> Tuple[NDArray[np.float64], NDArray[np.float64]]: ...
+
+def STOCHRSI(
+        real: NDArray[np.float64], 
+        timeperiod: int= 14, 
+        fastk_period: int= 5, 
+        fastd_period: int= 3, 
+        fastd_matype: MA_Type = MA_Type.SMA
+        )-> Tuple[NDArray[np.float64], NDArray[np.float64]]: ...
+
+def TRIX(
+        real: NDArray[np.float64], 
+        timeperiod: int= 30
+        )-> NDArray[np.float64]: ...
+
+def ULTOSC(
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64], 
+        timeperiod1: int= 7, 
+        timeperiod2: int= 14, 
+        timeperiod3: int= 28
+        )-> NDArray[np.float64]: ...
+
+def WILLR(
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64], 
+        timeperiod: int= 14
+        )-> NDArray[np.float64]: ...
+
+#Volume Indicator Functions
+
+def AD(
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64], 
+        volume: NDArray[np.float64]
+        )-> NDArray[np.float64]: ...
+
+def ADOSC(
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64], 
+        volume: NDArray[np.float64], 
+        fastperiod: int= 3, 
+        slowperiod: int= 10
+        )-> NDArray[np.float64]: ...
+
+def OBV(
+        close: NDArray[np.float64], 
+        volume: NDArray[np.float64]
+        )-> NDArray[np.float64]: ...
+
+#Volatility Indicator Functions
+
+def ATR(
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64], 
+        timeperiod: int= 14
+        )-> NDArray[np.float64]: ...
+
+def NATR(
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64], 
+        timeperiod: int= 14
+        )-> NDArray[np.float64]: ...
+
+def TRANGE(
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.float64]: ...
+
+# Price Transform Functions
+
+def AVGPRICE(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.float64]: ...
+
+def MEDPRICE(
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64]
+        )-> NDArray[np.float64]: ...
+
+def TYPPRICE(
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.float64]: ...
+
+def WCLPRICE(
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.float64]: ...
+
+# Cycle Indicator Functions
+
+def HT_DCPERIOD(real: NDArray[np.float64])-> NDArray[np.float64]: ...
+
+def HT_DCPHASE(real: NDArray[np.float64])-> NDArray[np.float64]: ...
+
+def HT_PHASOR(real: NDArray[np.float64])-> Tuple[NDArray[np.float64], NDArray[np.float64]]: ...
+
+def HT_SINE(real: NDArray[np.float64])-> Tuple[NDArray[np.float64], NDArray[np.float64]]: ...
+
+def HT_TRENDMODE(real: NDArray[np.float64])-> Tuple[NDArray[np.float64], NDArray[np.int32]]: ...
+
+#Pattern Recognition Functions
+
+def CDL2CROWS(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def CDL3BLACKCROWS(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def CDL3INSIDE(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def CDL3LINESTRIKE(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def CDL3OUTSIDE(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def CDL3STARSINSOUTH(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def CDL3WHITESOLDIERS(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def CDLABANDONEDBABY(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64],
+        penetration: float= 0
+        )-> NDArray[np.int32]: ...
+
+def CDLADVANCEBLOCK(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def CDLBELTHOLD(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def CDLBREAKAWAY(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def CDLCLOSINGMARUBOZU(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def CDLCONCEALBABYSWALL(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def CDLCOUNTERATTACK(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def CDLDARKCLOUDCOVER(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64],
+        penetration: float= 0
+        )-> NDArray[np.int32]: ...
+
+def CDLDOJI(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def CDLDOJISTAR(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def CDLDRAGONFLYDOJI(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def CDLENGULFING(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def CDLEVENINGDOJISTAR(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64],
+        penetration: float= 0
+        )-> NDArray[np.int32]: ...
+
+def CDLEVENINGSTAR(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64],
+        penetration: float= 0
+        )-> NDArray[np.int32]: ...
+
+def CDLGAPSIDESIDEWHITE(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def CDLGRAVESTONEDOJI(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def CDLHAMMER(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def CDLHANGINGMAN(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def CDLHARAMI(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def CDLHARAMICROSS(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def CDLHIGHWAVE(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def CDLHIKKAKE(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def CDLHIKKAKEMOD(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def CDLHOMINGPIGEON(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def CDLIDENTICAL3CROWS(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def CDLINNECK(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def CDLINVERTEDHAMMER(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def CDLKICKING(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def CDLKICKINGBYLENGTH(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def CDLLADDERBOTTOM(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def CDLLONGLEGGEDDOJI(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def CDLLONGLINE(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def CDLMARUBOZU(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def CDLMATCHINGLOW(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def CDLMATHOLD(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64],
+        penetration: float= 0
+        )-> NDArray[np.int32]: ...
+
+def CDLMORNINGDOJISTAR(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64],
+        penetration: float= 0
+        )-> NDArray[np.int32]: ...
+
+def CDLMORNINGSTAR(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64],
+        penetration: float= 0
+        )-> NDArray[np.int32]: ...
+
+def CDLONNECK(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def CDLPIERCING(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def CDLRICKSHAWMAN(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def CDLRISEFALL3METHODS(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def CDLSEPARATINGLINES(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def CDLSHOOTINGSTAR(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def CDLSHORTLINE(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def CDLSPINNINGTOP(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def CDLSTALLEDPATTERN(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def CDLSTICKSANDWICH(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def CDLTAKURI(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def CDLTASUKIGAP(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def CDLTHRUSTING(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def CDLTRISTAR(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def CDLUNIQUE3RIVER(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def CDLUPSIDEGAP2CROWS(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def CDLXSIDEGAP3METHODS(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+# Statistic Functions
+
+def BETA(
+        real0: NDArray[np.float64], 
+        real1: NDArray[np.float64], 
+        timeperiod: int= 5
+        )-> NDArray[np.float64]: ...
+
+def CORREL(
+        real0: NDArray[np.float64], 
+        real1: NDArray[np.float64], 
+        timeperiod: int= 30
+        )-> NDArray[np.float64]: ...
+
+def LINEARREG(
+        real: NDArray[np.float64], 
+        timeperiod: int= 14
+        )-> NDArray[np.float64]: ...
+
+def LINEARREG_ANGLE(
+        real: NDArray[np.float64], 
+        timeperiod: int= 14
+        )-> NDArray[np.float64]: ...
+
+def LINEARREG_INTERCEPT(
+        real: NDArray[np.float64], 
+        timeperiod: int= 14
+        )-> NDArray[np.float64]: ...
+
+def LINEARREG_SLOPE(
+        real: NDArray[np.float64], 
+        timeperiod: int= 14
+        )-> NDArray[np.float64]: ...
+
+def STDDEV(
+        real: NDArray[np.float64], 
+        timeperiod: int= 5, 
+        nbdev: float= 1
+        )-> NDArray[np.float64]: ...
+
+def TSF(
+        real: NDArray[np.float64], 
+        timeperiod: int= 14
+        )-> NDArray[np.float64]: ...
+
+def VAR(
+        real: NDArray[np.float64], 
+        timeperiod: int= 5, 
+        nbdev: float= 1
+        )-> NDArray[np.float64]: ...
+
+# Math Transform Functions
+
+def ACOS(real: NDArray[np.float64])-> NDArray[np.float64]: ...
+
+def ASIN(real: NDArray[np.float64])-> NDArray[np.float64]: ...
+
+def ATAN(real: NDArray[np.float64])-> NDArray[np.float64]: ...
+
+def CEIL(real: NDArray[np.float64])-> NDArray[np.float64]: ...
+
+def COS(real: NDArray[np.float64])-> NDArray[np.float64]: ...
+
+def COSH(real: NDArray[np.float64])-> NDArray[np.float64]: ...
+
+def EXP(real: NDArray[np.float64])-> NDArray[np.float64]: ...
+
+def FLOOR(real: NDArray[np.float64])-> NDArray[np.float64]: ...
+
+def LN(real: NDArray[np.float64])-> NDArray[np.float64]: ...
+
+def LOG10(real: NDArray[np.float64])-> NDArray[np.float64]: ...
+
+def SIN(real: NDArray[np.float64])-> NDArray[np.float64]: ...
+
+def SINH(real: NDArray[np.float64])-> NDArray[np.float64]: ...
+
+def SQRT(real: NDArray[np.float64])-> NDArray[np.float64]: ...
+
+def TAN(real: NDArray[np.float64])-> NDArray[np.float64]: ...
+
+def TANH(real: NDArray[np.float64])-> NDArray[np.float64]: ...
+
+#Math Operator Functions
+
+def ADD(
+        real0: NDArray[np.float64], 
+        real1: NDArray[np.float64]
+        )-> NDArray[np.float64]: ...
+
+def DIV(
+        real0: NDArray[np.float64], 
+        real1: NDArray[np.float64]
+        )-> NDArray[np.float64]: ...
+
+def MAX(
+        real: NDArray[np.float64], 
+        timeperiod: int= 30
+        )-> NDArray[np.float64]: ...
+
+def MAXINDEX(
+        real: NDArray[np.float64], 
+        timeperiod: int= 30
+        )-> NDArray[np.int32]: ...
+
+def MIN(
+        real: NDArray[np.float64], 
+        timeperiod: int= 30
+        )-> NDArray[np.float64]: ...
+
+def MININDEX(
+        real: NDArray[np.float64], 
+        timeperiod: int= 30
+        )-> NDArray[np.int32]: ...
+
+def MINMAX(
+        real: NDArray[np.float64], 
+        timeperiod: int= 30
+        )-> Tuple[NDArray[np.float64], NDArray[np.float64]]: ...
+
+def MINMAXINDEX(
+        real: NDArray[np.float64], 
+        timeperiod: int= 30
+        )-> Tuple[NDArray[np.float64], NDArray[np.float64]]: ...
+
+def MULT(
+        real0: NDArray[np.float64], 
+        real1: NDArray[np.float64]
+        )-> NDArray[np.float64]: ...
+
+def SUB(
+        real0: NDArray[np.float64], 
+        real1: NDArray[np.float64]
+        )-> NDArray[np.float64]: ...
+
+def SUM(
+        real: NDArray[np.float64], 
+        timeperiod: int= 30
+        )-> NDArray[np.float64]: ...
+
+def ACCBANDS(
+        high: NDArray[np.float64],
+        low: NDArray[np.float64],
+        close: NDArray[np.float64],
+        timeperiod: int= 20
+        )-> NDArray[np.float64]: ...
+
+def AVGDEV(
+        real: NDArray[np.float64], 
+        timeperiod: int= 14
+        )-> NDArray[np.float64]: ...
+
+def IMI(
+        open: NDArray[np.float64], 
+        close: NDArray[np.float64], 
+        timeperiod: int= 14
+        )-> NDArray[np.float64]: ...
+
+#Overlap Studies Functions
+
+def stream_BBANDS(
+        real: NDArray[np.float64],  
+        timeperiod: int= 5, 
+        nbdevup: float= 2, 
+        nbdevdn: float= 2, 
+        matype: MA_Type = MA_Type.SMA
+        )-> Tuple[NDArray[np.float64], NDArray[np.float64], NDArray[np.float64]]: ...
+
+def stream_DEMA(
+        real: NDArray[np.float64], 
+        timeperiod: int= 30
+        )-> NDArray[np.float64]: ...
+
+def stream_EMA(
+        real: NDArray[np.float64], 
+        timeperiod: int= 30
+        )-> NDArray[np.float64]: ...
+
+def stream_HT_TRENDLINE(real: NDArray[np.float64])-> NDArray[np.float64]: ...
+
+def stream_KAMA(
+        real: NDArray[np.float64], 
+        timeperiod: int= 30
+        )-> NDArray[np.float64]: ...
+
+def stream_MA(
+        real: NDArray[np.float64], 
+        timeperiod: int= 30,
+        matype: MA_Type = MA_Type.SMA
+        )-> NDArray[np.float64]: ...
+
+def stream_MAMA(
+        real: NDArray[np.float64], 
+        fastlimit: float= 0, 
+        slowlimit: float= 0
+        )-> Tuple[NDArray[np.float64], NDArray[np.float64]]: ...
+
+def stream_MAVP(
+        real: NDArray[np.float64], 
+        periods: float, 
+        minperiod: int= 2, 
+        maxperiod: int= 30, 
+        matype: MA_Type = MA_Type.SMA
+        )-> NDArray[np.float64]: ...
+
+def stream_MIDPOINT(
+        real: NDArray[np.float64], 
+        timeperiod: int= 14
+        )-> NDArray[np.float64]: ...
+
+def stream_MIDPRICE(
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        timeperiod: int= 14
+        )-> NDArray[np.float64]: ...
+
+def stream_SAR(
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        acceleration: float= 0, 
+        maximum: float= 0
+        )-> NDArray[np.float64]: ...
+
+def stream_SAREXT(
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        startvalue: float= 0, 
+        offsetonreverse: float= 0, 
+        accelerationinitlong: float= 0, 
+        accelerationlong: float= 0, 
+        accelerationmaxlong: float= 0, 
+        accelerationinitshort: float= 0, 
+        accelerationshort: float= 0, 
+        accelerationmaxshort: float= 0
+        )-> NDArray[np.float64]: ...
+
+def stream_SMA(
+        real: NDArray[np.float64], 
+        timeperiod: int= 30
+        )-> NDArray[np.float64]: ...
+
+def stream_T3(
+        real: NDArray[np.float64], 
+        timeperiod: int= 5, 
+        vfactor: float= 0
+        )-> NDArray[np.float64]: ...
+
+def stream_TEMA(
+        real: NDArray[np.float64], 
+        timeperiod: int= 30
+        )-> NDArray[np.float64]: ...
+
+def stream_TRIMA(
+        real: NDArray[np.float64], 
+        timeperiod: int= 30
+        )-> NDArray[np.float64]: ...
+
+def stream_WMA(
+        real: NDArray[np.float64], 
+        timeperiod: int= 30
+        )-> NDArray[np.float64]: ...
+
+#Momentum Indicator Functions
+
+def stream_ADX(
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64], 
+        timeperiod: int= 14
+        )-> NDArray[np.float64]: ...
+
+def stream_ADXR(
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64], 
+        timeperiod: int= 14
+        )-> NDArray[np.float64]: ...
+
+def stream_APO(
+        real: NDArray[np.float64], 
+        fastperiod: int= 12, 
+        slowperiod: int= 26, 
+        matype: MA_Type = MA_Type.SMA
+        )-> NDArray[np.float64]: ...
+
+def stream_AROON(
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        timeperiod: int= 14
+        )-> Tuple[NDArray[np.float64], NDArray[np.float64]]: ...
+
+def stream_AROONOSC(
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        timeperiod: int= 14
+        )-> NDArray[np.float64]: ...
+
+def stream_BOP(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.float64]: ...
+
+def stream_CCI(
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64], 
+        timeperiod: int= 14
+        )-> NDArray[np.float64]: ...
+
+def stream_CMO(
+        real: NDArray[np.float64], 
+        timeperiod: int= 14
+        )-> NDArray[np.float64]: ...
+
+def stream_DX(
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64], 
+        timeperiod: int= 14
+        )-> NDArray[np.float64]: ...
+
+def stream_MACD(
+        real: NDArray[np.float64], 
+        fastperiod: int= 12, 
+        slowperiod: int= 26, 
+        signalperiod: int= 9
+        )-> Tuple[NDArray[np.float64], NDArray[np.float64], NDArray[np.float64]]: ...
+
+def stream_MACDEXT(
+        real: NDArray[np.float64], 
+        fastperiod: int= 12, 
+        fastmatype: MA_Type = MA_Type.SMA, 
+        slowperiod: int= 26, 
+        slowmatype: MA_Type = MA_Type.SMA, 
+        signalperiod: int= 9, 
+        signalmatype: MA_Type = MA_Type.SMA
+        )-> Tuple[NDArray[np.float64], NDArray[np.float64], NDArray[np.float64]]: ...
+
+def stream_MACDFIX(
+        real: NDArray[np.float64], 
+        signalperiod: int= 9
+        )-> Tuple[NDArray[np.float64], NDArray[np.float64], NDArray[np.float64]]: ...
+
+def stream_MFI(
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64], 
+        volume: NDArray[np.float64], 
+        timeperiod: int= 14
+        )-> NDArray[np.float64]: ...
+
+def stream_MINUS_DI(
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64], 
+        timeperiod: int= 14
+        )-> NDArray[np.float64]: ...
+
+def stream_MINUS_DM(
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        timeperiod: int= 14
+        )-> NDArray[np.float64]: ...
+
+def stream_MOM(
+        real: NDArray[np.float64], 
+        timeperiod: int= 10
+        )-> NDArray[np.float64]: ...
+
+def stream_PLUS_DI(
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64], 
+        timeperiod: int= 14
+        )-> NDArray[np.float64]: ...
+
+def stream_PLUS_DM(
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        timeperiod: int= 14
+        )-> NDArray[np.float64]: ...
+
+def stream_PPO(
+        real: NDArray[np.float64], 
+        fastperiod: int= 12, 
+        slowperiod: int= 26, 
+        matype: MA_Type = MA_Type.SMA
+        )-> NDArray[np.float64]: ...
+
+def stream_ROC(
+        real: NDArray[np.float64], 
+        timeperiod: int= 10
+        )-> NDArray[np.float64]: ...
+
+def stream_ROCP(
+        real: NDArray[np.float64], 
+        timeperiod: int= 10
+        )-> NDArray[np.float64]: ...
+
+def stream_ROCR(
+        real: NDArray[np.float64], 
+        timeperiod: int= 10
+        )-> NDArray[np.float64]: ...
+
+def stream_ROCR100(
+        real: NDArray[np.float64], 
+        timeperiod: int= 10
+        )-> NDArray[np.float64]: ...
+
+def stream_RSI(
+        real: NDArray[np.float64], 
+        timeperiod: int= 14
+        )-> NDArray[np.float64]: ...
+
+def stream_STOCH(
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64], 
+        fastk_period: int= 5, 
+        slowk_period: int= 3, 
+        slowk_matype: MA_Type = MA_Type.SMA, 
+        slowd_period: int= 3, 
+        slowd_matype: MA_Type = MA_Type.SMA
+        )-> Tuple[NDArray[np.float64], NDArray[np.float64]]: ...
+
+def stream_STOCHF(
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64], 
+        fastk_period: int= 5, 
+        fastd_period: int= 3, 
+        fastd_matype: MA_Type = MA_Type.SMA
+        )-> Tuple[NDArray[np.float64], NDArray[np.float64]]: ...
+
+def stream_STOCHRSI(
+        real: NDArray[np.float64], 
+        timeperiod: int= 14, 
+        fastk_period: int= 5, 
+        fastd_period: int= 3, 
+        fastd_matype: MA_Type = MA_Type.SMA
+        )-> Tuple[NDArray[np.float64], NDArray[np.float64]]: ...
+
+def stream_TRIX(
+        real: NDArray[np.float64], 
+        timeperiod: int= 30
+        )-> NDArray[np.float64]: ...
+
+def stream_ULTOSC(
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64], 
+        timeperiod1: int= 7, 
+        timeperiod2: int= 14, 
+        timeperiod3: int= 28
+        )-> NDArray[np.float64]: ...
+
+def stream_WILLR(
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64], 
+        timeperiod: int= 14
+        )-> NDArray[np.float64]: ...
+
+#Volume Indicator Functions
+
+def stream_AD(
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64], 
+        volume: NDArray[np.float64]
+        )-> NDArray[np.float64]: ...
+
+def stream_ADOSC(
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64], 
+        volume: NDArray[np.float64], 
+        fastperiod: int= 3, 
+        slowperiod: int= 10
+        )-> NDArray[np.float64]: ...
+
+def stream_OBV(
+        close: NDArray[np.float64], 
+        volume: NDArray[np.float64]
+        )-> NDArray[np.float64]: ...
+
+#Volatility Indicator Functions
+
+def stream_ATR(
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64], 
+        timeperiod: int= 14
+        )-> NDArray[np.float64]: ...
+
+def stream_NATR(
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64], 
+        timeperiod: int= 14
+        )-> NDArray[np.float64]: ...
+
+def stream_TRANGE(
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.float64]: ...
+
+# Price Transform Functions
+
+def stream_AVGPRICE(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.float64]: ...
+
+def stream_MEDPRICE(
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64]
+        )-> NDArray[np.float64]: ...
+
+def stream_TYPPRICE(
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.float64]: ...
+
+def stream_WCLPRICE(
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.float64]: ...
+
+# Cycle Indicator Functions
+
+def stream_HT_DCPERIOD(real: NDArray[np.float64])-> NDArray[np.float64]: ...
+
+def stream_HT_DCPHASE(real: NDArray[np.float64])-> NDArray[np.float64]: ...
+
+def stream_HT_PHASOR(real: NDArray[np.float64])-> Tuple[NDArray[np.float64], NDArray[np.float64]]: ...
+
+def stream_HT_SINE(real: NDArray[np.float64])-> Tuple[NDArray[np.float64], NDArray[np.float64]]: ...
+
+def stream_HT_TRENDMODE(real: NDArray[np.float64])-> Tuple[NDArray[np.float64], NDArray[np.int32]]: ...
+
+#Pattern Recognition Functions
+
+def stream_CDL2CROWS(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def stream_CDL3BLACKCROWS(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def stream_CDL3INSIDE(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def stream_CDL3LINESTRIKE(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def stream_CDL3OUTSIDE(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def stream_CDL3STARSINSOUTH(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def stream_CDL3WHITESOLDIERS(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def stream_CDLABANDONEDBABY(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64],
+        penetration: float= 0
+        )-> NDArray[np.int32]: ...
+
+def stream_CDLADVANCEBLOCK(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def stream_CDLBELTHOLD(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def stream_CDLBREAKAWAY(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def stream_CDLCLOSINGMARUBOZU(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def stream_CDLCONCEALBABYSWALL(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def stream_CDLCOUNTERATTACK(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def stream_CDLDARKCLOUDCOVER(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64],
+        penetration: float= 0
+        )-> NDArray[np.int32]: ...
+
+def stream_CDLDOJI(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def stream_CDLDOJISTAR(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def stream_CDLDRAGONFLYDOJI(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def stream_CDLENGULFING(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def stream_CDLEVENINGDOJISTAR(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64],
+        penetration: float= 0
+        )-> NDArray[np.int32]: ...
+
+def stream_CDLEVENINGSTAR(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64],
+        penetration: float= 0
+        )-> NDArray[np.int32]: ...
+
+def stream_CDLGAPSIDESIDEWHITE(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def stream_CDLGRAVESTONEDOJI(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def stream_CDLHAMMER(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def stream_CDLHANGINGMAN(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def stream_CDLHARAMI(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def stream_CDLHARAMICROSS(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def stream_CDLHIGHWAVE(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def stream_CDLHIKKAKE(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def stream_CDLHIKKAKEMOD(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def stream_CDLHOMINGPIGEON(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def stream_CDLIDENTICAL3CROWS(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def stream_CDLINNECK(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def stream_CDLINVERTEDHAMMER(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def stream_CDLKICKING(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def stream_CDLKICKINGBYLENGTH(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def stream_CDLLADDERBOTTOM(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def stream_CDLLONGLEGGEDDOJI(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def stream_CDLLONGLINE(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def stream_CDLMARUBOZU(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def stream_CDLMATCHINGLOW(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def stream_CDLMATHOLD(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64],
+        penetration: float= 0
+        )-> NDArray[np.int32]: ...
+
+def stream_CDLMORNINGDOJISTAR(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64],
+        penetration: float= 0
+        )-> NDArray[np.int32]: ...
+
+def stream_CDLMORNINGSTAR(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64],
+        penetration: float= 0
+        )-> NDArray[np.int32]: ...
+
+def stream_CDLONNECK(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def stream_CDLPIERCING(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def stream_CDLRICKSHAWMAN(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def stream_CDLRISEFALL3METHODS(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def stream_CDLSEPARATINGLINES(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def stream_CDLSHOOTINGSTAR(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def stream_CDLSHORTLINE(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def stream_CDLSPINNINGTOP(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def stream_CDLSTALLEDPATTERN(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def stream_CDLSTICKSANDWICH(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def stream_CDLTAKURI(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def stream_CDLTASUKIGAP(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def stream_CDLTHRUSTING(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def stream_CDLTRISTAR(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def stream_CDLUNIQUE3RIVER(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def stream_CDLUPSIDEGAP2CROWS(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+def stream_CDLXSIDEGAP3METHODS(
+        open: NDArray[np.float64], 
+        high: NDArray[np.float64], 
+        low: NDArray[np.float64], 
+        close: NDArray[np.float64]
+        )-> NDArray[np.int32]: ...
+
+# Statistic Functions
+
+def stream_BETA(
+        real0: NDArray[np.float64], 
+        real1: NDArray[np.float64], 
+        timeperiod: int= 5
+        )-> NDArray[np.float64]: ...
+
+def stream_CORREL(
+        real0: NDArray[np.float64], 
+        real1: NDArray[np.float64], 
+        timeperiod: int= 30
+        )-> NDArray[np.float64]: ...
+
+def stream_LINEARREG(
+        real: NDArray[np.float64], 
+        timeperiod: int= 14
+        )-> NDArray[np.float64]: ...
+
+def stream_LINEARREG_ANGLE(
+        real: NDArray[np.float64], 
+        timeperiod: int= 14
+        )-> NDArray[np.float64]: ...
+
+def stream_LINEARREG_INTERCEPT(
+        real: NDArray[np.float64], 
+        timeperiod: int= 14
+        )-> NDArray[np.float64]: ...
+
+def stream_LINEARREG_SLOPE(
+        real: NDArray[np.float64], 
+        timeperiod: int= 14
+        )-> NDArray[np.float64]: ...
+
+def stream_STDDEV(
+        real: NDArray[np.float64], 
+        timeperiod: int= 5, 
+        nbdev: float= 1
+        )-> NDArray[np.float64]: ...
+
+def stream_TSF(
+        real: NDArray[np.float64], 
+        timeperiod: int= 14
+        )-> NDArray[np.float64]: ...
+
+def stream_VAR(
+        real: NDArray[np.float64], 
+        timeperiod: int= 5, 
+        nbdev: float= 1
+        )-> NDArray[np.float64]: ...
+
+# Math Transform Functions
+
+def stream_ACOS(real: NDArray[np.float64])-> NDArray[np.float64]: ...
+
+def stream_ASIN(real: NDArray[np.float64])-> NDArray[np.float64]: ...
+
+def stream_ATAN(real: NDArray[np.float64])-> NDArray[np.float64]: ...
+
+def stream_CEIL(real: NDArray[np.float64])-> NDArray[np.float64]: ...
+
+def stream_COS(real: NDArray[np.float64])-> NDArray[np.float64]: ...
+
+def stream_COSH(real: NDArray[np.float64])-> NDArray[np.float64]: ...
+
+def stream_EXP(real: NDArray[np.float64])-> NDArray[np.float64]: ...
+
+def stream_FLOOR(real: NDArray[np.float64])-> NDArray[np.float64]: ...
+
+def stream_LN(real: NDArray[np.float64])-> NDArray[np.float64]: ...
+
+def stream_LOG10(real: NDArray[np.float64])-> NDArray[np.float64]: ...
+
+def stream_SIN(real: NDArray[np.float64])-> NDArray[np.float64]: ...
+
+def stream_SINH(real: NDArray[np.float64])-> NDArray[np.float64]: ...
+
+def stream_SQRT(real: NDArray[np.float64])-> NDArray[np.float64]: ...
+
+def stream_TAN(real: NDArray[np.float64])-> NDArray[np.float64]: ...
+
+def stream_TANH(real: NDArray[np.float64])-> NDArray[np.float64]: ...
+
+#Math Operator Functions
+
+def stream_ADD(
+        real0: NDArray[np.float64], 
+        real1: NDArray[np.float64]
+        )-> NDArray[np.float64]: ...
+
+def stream_DIV(
+        real0: NDArray[np.float64], 
+        real1: NDArray[np.float64]
+        )-> NDArray[np.float64]: ...
+
+def stream_MAX(
+        real: NDArray[np.float64], 
+        timeperiod: int= 30
+        )-> NDArray[np.float64]: ...
+
+def stream_MAXINDEX(
+        real: NDArray[np.float64], 
+        timeperiod: int= 30
+        )-> NDArray[np.int32]: ...
+
+def stream_MIN(
+        real: NDArray[np.float64], 
+        timeperiod: int= 30
+        )-> NDArray[np.float64]: ...
+
+def stream_MININDEX(
+        real: NDArray[np.float64], 
+        timeperiod: int= 30
+        )-> NDArray[np.int32]: ...
+
+def stream_MINMAX(
+        real: NDArray[np.float64], 
+        timeperiod: int= 30
+        )-> Tuple[NDArray[np.float64], NDArray[np.float64]]: ...
+
+def stream_MINMAXINDEX(
+        real: NDArray[np.float64], 
+        timeperiod: int= 30
+        )-> Tuple[NDArray[np.float64], NDArray[np.float64]]: ...
+
+def stream_MULT(
+        real0: NDArray[np.float64], 
+        real1: NDArray[np.float64]
+        )-> NDArray[np.float64]: ...
+
+def stream_SUB(
+        real0: NDArray[np.float64], 
+        real1: NDArray[np.float64]
+        )-> NDArray[np.float64]: ...
+
+def stream_SUM(
+        real: NDArray[np.float64], 
+        timeperiod: int= 30
+        )-> NDArray[np.float64]: ...
+
+def stream_ACCBANDS(
+        high: NDArray[np.float64],
+        low: NDArray[np.float64],
+        close: NDArray[np.float64],
+        timeperiod: int= 20
+        )-> NDArray[np.float64]: ...
+
+def stream_AVGDEV(
+        real: NDArray[np.float64], 
+        timeperiod: int= 14
+        )-> NDArray[np.float64]: ...
+
+def stream_IMI(
+        open: NDArray[np.float64], 
+        close: NDArray[np.float64], 
+        timeperiod: int= 14
+        )-> NDArray[np.float64]: ...
diff --git a/talib/_ta_lib.pyx b/talib/_ta_lib.pyx
index 3bb1a994b..2b8aec2b6 100644
--- a/talib/_ta_lib.pyx
+++ b/talib/_ta_lib.pyx
@@ -1,4 +1,8 @@
+#cython: embedsignature=True, emit_code_comments=False
+
 include "_common.pxi"
 include "_func.pxi"
 include "_abstract.pxi"
 include "_stream.pxi"
+
+__all__ = __TA_FUNCTION_NAMES__ + ["stream_%s" % name for name in __TA_FUNCTION_NAMES__]
diff --git a/talib/py.typed b/talib/py.typed
new file mode 100644
index 000000000..e69de29bb
diff --git a/talib/test_data.py b/talib/test_data.py
deleted file mode 100644
index 3fbaf37f5..000000000
--- a/talib/test_data.py
+++ /dev/null
@@ -1,242 +0,0 @@
-
-from __future__ import print_function
-
-import numpy as np
-
-from nose.tools import assert_equal, assert_not_equal, assert_true
-
-ford_2012_dates = np.asarray([ 20120103, 20120104, 20120105, 20120106, 20120109,
-    20120110, 20120111, 20120112, 20120113, 20120117, 20120118, 20120119,
-    20120120, 20120123, 20120124, 20120125, 20120126, 20120127, 20120130,
-    20120131, 20120201, 20120202, 20120203, 20120206, 20120207, 20120208,
-    20120209, 20120210, 20120213, 20120214, 20120215, 20120216, 20120217,
-    20120221, 20120222, 20120223, 20120224, 20120227, 20120228, 20120229,
-    20120301, 20120302, 20120305, 20120306, 20120307, 20120308, 20120309,
-    20120312, 20120313, 20120314, 20120315, 20120316, 20120319, 20120320,
-    20120321, 20120322, 20120323, 20120326, 20120327, 20120328, 20120329,
-    20120330, 20120402, 20120403, 20120404, 20120405, 20120409, 20120410,
-    20120411, 20120412, 20120413, 20120416, 20120417, 20120418, 20120419,
-    20120420, 20120423, 20120424, 20120425, 20120426, 20120427, 20120430,
-    20120501, 20120502, 20120503, 20120504, 20120507, 20120508, 20120509,
-    20120510, 20120511, 20120514, 20120515, 20120516, 20120517, 20120518,
-    20120521, 20120522, 20120523, 20120524, 20120525, 20120529, 20120530,
-    20120531, 20120601, 20120604, 20120605, 20120606, 20120607, 20120608,
-    20120611, 20120612, 20120613, 20120614, 20120615, 20120618, 20120619,
-    20120620, 20120621, 20120622, 20120625, 20120626, 20120627, 20120628,
-    20120629, 20120702, 20120703, 20120705, 20120706, 20120709, 20120710,
-    20120711, 20120712, 20120713, 20120716, 20120717, 20120718, 20120719,
-    20120720, 20120723, 20120724, 20120725, 20120726, 20120727, 20120730,
-    20120731, 20120801, 20120802, 20120803, 20120806, 20120807, 20120808,
-    20120809, 20120810, 20120813, 20120814, 20120815, 20120816, 20120817,
-    20120820, 20120821, 20120822, 20120823, 20120824, 20120827, 20120828,
-    20120829, 20120830, 20120831, 20120904, 20120905, 20120906, 20120907,
-    20120910, 20120911, 20120912, 20120913, 20120914, 20120917, 20120918,
-    20120919, 20120920, 20120921, 20120924, 20120925, 20120926, 20120927,
-    20120928, 20121001, 20121002, 20121003, 20121004, 20121005, 20121008,
-    20121009, 20121010, 20121011, 20121012, 20121015, 20121016, 20121017,
-    20121018, 20121019, 20121022, 20121023, 20121024, 20121025, 20121026,
-    20121031, 20121101, 20121102, 20121105, 20121106, 20121107, 20121108,
-    20121109, 20121112, 20121113, 20121114, 20121115, 20121116, 20121119,
-    20121120, 20121121, 20121123, 20121126, 20121127, 20121128, 20121129,
-    20121130, 20121203, 20121204, 20121205, 20121206, 20121207, 20121210,
-    20121211, 20121212, 20121213, 20121214, 20121217, 20121218, 20121219,
-    20121220, 20121221, 20121224, 20121226, 20121227, 20121228, 20121231 ])
-
-ford_2012 = {
-    'open': np.asarray([ 11.00, 11.15, 11.33, 11.74, 11.83, 12.00, 11.74, 12.16,
-        12.01, 12.20, 12.03, 12.48, 12.55, 12.69, 12.56, 12.80, 13.03, 11.96,
-        12.06, 12.47, 12.73, 12.40, 12.47, 12.85, 12.93, 12.91, 12.89, 12.52,
-        12.74, 12.46, 12.47, 12.38, 12.84, 12.74, 12.49, 12.27, 12.43, 12.11,
-        12.34, 12.28, 12.48, 12.74, 12.67, 12.23, 12.21, 12.41, 12.53, 12.57,
-        12.48, 12.64, 12.90, 12.86, 12.52, 12.48, 12.59, 12.48, 12.31, 12.45,
-        12.51, 12.35, 12.33, 12.55, 12.50, 12.71, 12.46, 12.38, 12.26, 12.19,
-        11.99, 11.94, 11.98, 12.01, 11.98, 11.81, 11.81, 11.71, 11.15, 11.61,
-        11.51, 11.71, 12.03, 11.42, 11.25, 11.16, 11.13, 10.84, 10.53, 10.60,
-        10.48, 10.83, 10.61, 10.41, 10.34, 10.23, 10.16, 10.08, 10.02, 10.25,
-        10.32, 10.50, 10.61, 10.69, 10.73, 10.62, 10.33, 10.15, 10.01, 10.29,
-        10.73, 10.48, 10.77, 10.47, 10.39, 10.27, 10.40, 10.35, 10.37, 10.58,
-        10.65, 10.35, 10.13, 10.06, 10.05, 9.93, 9.95, 9.50, 9.53, 9.67, 9.47,
-        9.46, 9.50, 9.33, 9.26, 9.16, 9.22, 9.28, 9.38, 9.45, 9.28, 9.08, 9.17,
-        9.17, 9.05, 8.99, 9.04, 9.13, 9.29, 8.99, 9.02, 9.13, 9.18, 9.25, 9.31,
-        9.30, 9.35, 9.45, 9.44, 9.50, 9.65, 9.58, 9.65, 9.50, 9.45, 9.42, 9.51,
-        9.37, 9.33, 9.30, 9.39, 9.37, 9.45, 9.66, 9.95, 10.08, 10.18, 10.25,
-        10.20, 10.41, 10.27, 10.30, 10.49, 10.48, 10.53, 10.30, 10.35, 9.98,
-        10.13, 9.99, 9.89, 10.01, 9.82, 10.06, 10.17, 10.06, 10.21, 10.12,
-        10.06, 10.14, 10.11, 10.26, 10.31, 10.36, 10.42, 10.14, 10.02, 10.08,
-        10.42, 10.35, 10.70, 11.19, 11.31, 11.15, 11.33, 11.25, 11.07, 10.76,
-        11.03, 10.89, 11.02, 10.57, 10.58, 10.65, 10.85, 10.84, 10.98, 11.05,
-        11.10, 11.05, 11.32, 11.52, 11.56, 11.40, 11.32, 11.26, 11.27, 11.41,
-        11.51, 11.52, 11.46, 11.27, 11.16, 11.48, 11.79, 11.74, 11.55, 11.67,
-        12.31, 12.79, 12.55, 12.88, ]),
-
-    'high': np.asarray([ 11.25, 11.53, 11.63, 11.80, 11.95, 12.05, 12.18, 12.18,
-        12.08, 12.26, 12.37, 12.72, 12.64, 12.84, 12.86, 12.98, 13.05, 12.53,
-        12.44, 12.51, 12.75, 12.43, 12.84, 13.00, 12.97, 12.96, 12.90, 12.66,
-        12.74, 12.58, 12.57, 12.77, 12.88, 12.76, 12.51, 12.44, 12.46, 12.36,
-        12.35, 12.55, 12.77, 12.94, 12.68, 12.25, 12.30, 12.55, 12.73, 12.59,
-        12.72, 12.90, 13.04, 12.90, 12.68, 12.61, 12.67, 12.54, 12.37, 12.50,
-        12.61, 12.36, 12.52, 12.58, 12.65, 12.95, 12.52, 12.58, 12.29, 12.28,
-        12.02, 12.13, 12.03, 12.05, 12.00, 11.85, 11.88, 11.72, 11.40, 11.61,
-        11.75, 11.93, 12.04, 11.47, 11.34, 11.17, 11.15, 10.87, 10.79, 10.64,
-        10.81, 10.86, 10.83, 10.53, 10.34, 10.43, 10.25, 10.18, 10.23, 10.40,
-        10.45, 10.62, 10.68, 10.88, 10.75, 10.68, 10.37, 10.18, 10.24, 10.58,
-        10.78, 10.68, 10.80, 10.55, 10.49, 10.45, 10.42, 10.40, 10.64, 10.74,
-        10.68, 10.40, 10.18, 10.08, 10.10, 10.09, 9.98, 9.60, 9.79, 9.74, 9.52,
-        9.47, 9.55, 9.38, 9.28, 9.32, 9.32, 9.35, 9.52, 9.50, 9.35, 9.21, 9.24,
-        9.20, 9.11, 9.10, 9.18, 9.28, 9.42, 9.03, 9.15, 9.21, 9.39, 9.38, 9.46,
-        9.36, 9.42, 9.66, 9.54, 9.67, 9.66, 9.64, 9.70, 9.56, 9.54, 9.52, 9.52,
-        9.44, 9.40, 9.34, 9.43, 9.47, 9.62, 9.96, 10.23, 10.28, 10.25, 10.30,
-        10.38, 10.57, 10.42, 10.45, 10.66, 10.52, 10.54, 10.40, 10.37, 10.12,
-        10.18, 10.00, 10.08, 10.05, 10.02, 10.15, 10.28, 10.12, 10.25, 10.12,
-        10.26, 10.25, 10.25, 10.32, 10.41, 10.57, 10.43, 10.24, 10.11, 10.29,
-        10.49, 10.42, 11.17, 11.30, 11.38, 11.35, 11.59, 11.34, 11.23, 11.10,
-        11.16, 11.10, 11.05, 10.80, 10.64, 10.90, 11.02, 11.00, 11.10, 11.14,
-        11.27, 11.26, 11.53, 11.60, 11.70, 11.44, 11.40, 11.31, 11.50, 11.53,
-        11.58, 11.56, 11.50, 11.27, 11.41, 11.68, 11.85, 11.80, 11.86, 12.40,
-        12.79, 12.81, 12.88, 13.08, ]),
-
-    'low': np.asarray([ 10.99, 11.07, 11.24, 11.52, 11.70, 11.63, 11.65, 11.89,
-        11.84, 11.96, 12.00, 12.43, 12.45, 12.55, 12.46, 12.70, 12.66, 11.79,
-        12.00, 12.20, 12.29, 12.20, 12.39, 12.71, 12.83, 12.80, 12.67, 12.37,
-        12.51, 12.34, 12.33, 12.38, 12.71, 12.46, 12.22, 12.16, 12.19, 11.99,
-        12.20, 12.25, 12.45, 12.68, 12.41, 12.00, 12.15, 12.32, 12.48, 12.37,
-        12.40, 12.63, 12.83, 12.51, 12.48, 12.39, 12.55, 12.24, 12.18, 12.39,
-        12.30, 12.18, 12.24, 12.40, 12.44, 12.46, 12.32, 12.38, 12.11, 11.65,
-        11.88, 11.86, 11.84, 11.83, 11.88, 11.72, 11.58, 11.39, 11.15, 11.36,
-        11.43, 11.67, 11.52, 11.15, 11.11, 11.00, 10.85, 10.63, 10.52, 10.40,
-        10.41, 10.66, 10.56, 10.30, 10.10, 10.15, 10.01, 9.96, 10.00, 10.15,
-        10.22, 10.38, 10.51, 10.68, 10.52, 10.40, 10.06, 9.91, 9.97, 10.27,
-        10.52, 10.38, 10.45, 10.31, 10.22, 10.21, 10.26, 10.26, 10.35, 10.52,
-        10.25, 10.18, 9.95, 9.96, 9.97, 9.93, 9.46, 9.30, 9.49, 9.53, 9.40,
-        9.31, 9.28, 9.26, 9.12, 9.14, 9.15, 9.12, 9.34, 9.33, 9.18, 9.05, 8.95,
-        8.91, 8.83, 8.88, 9.01, 9.12, 8.99, 8.82, 8.96, 9.09, 9.18, 9.24, 9.30,
-        9.23, 9.25, 9.42, 9.41, 9.49, 9.60, 9.51, 9.52, 9.40, 9.42, 9.41, 9.38,
-        9.31, 9.29, 9.25, 9.31, 9.35, 9.39, 9.66, 9.93, 10.06, 10.13, 10.17,
-        10.12, 10.39, 10.26, 10.28, 10.45, 10.35, 10.36, 10.26, 10.06, 9.86,
-        10.02, 9.81, 9.88, 9.71, 9.76, 9.96, 10.13, 9.99, 10.02, 9.95, 10.05,
-        10.09, 10.09, 10.22, 10.26, 10.33, 10.13, 10.03, 9.97, 10.01, 10.28,
-        10.22, 10.60, 10.88, 11.15, 11.13, 11.26, 11.04, 10.89, 10.71, 10.96,
-        10.86, 10.62, 10.46, 10.38, 10.65, 10.76, 10.80, 10.96, 10.97, 11.10,
-        10.98, 11.32, 11.33, 11.40, 11.23, 11.18, 11.19, 11.26, 11.41, 11.40,
-        11.43, 11.21, 11.03, 11.14, 11.40, 11.62, 11.58, 11.47, 11.67, 12.31,
-        12.36, 12.52, 12.76, ]),
-
-    'close': np.asarray([ 11.13, 11.30, 11.59, 11.71, 11.80, 11.80, 12.07, 12.14,
-        12.04, 12.02, 12.34, 12.61, 12.59, 12.66, 12.82, 12.93, 12.79, 12.21,
-        12.29, 12.42, 12.33, 12.26, 12.79, 12.96, 12.88, 12.84, 12.69, 12.44,
-        12.54, 12.48, 12.38, 12.74, 12.75, 12.53, 12.28, 12.40, 12.23, 12.30,
-        12.25, 12.38, 12.66, 12.72, 12.46, 12.09, 12.24, 12.46, 12.58, 12.43,
-        12.70, 12.88, 12.90, 12.51, 12.63, 12.54, 12.57, 12.32, 12.32, 12.48,
-        12.32, 12.32, 12.50, 12.48, 12.62, 12.64, 12.51, 12.47, 12.22, 11.79,
-        11.91, 12.07, 11.92, 11.88, 11.91, 11.79, 11.66, 11.41, 11.35, 11.39,
-        11.73, 11.87, 11.60, 11.28, 11.23, 11.10, 10.92, 10.67, 10.66, 10.61,
-        10.69, 10.71, 10.58, 10.32, 10.15, 10.16, 10.01, 10.01, 10.20, 10.19,
-        10.41, 10.59, 10.60, 10.84, 10.66, 10.56, 10.12, 10.04, 10.19, 10.57,
-        10.55, 10.66, 10.45, 10.50, 10.30, 10.41, 10.35, 10.34, 10.56, 10.65,
-        10.27, 10.19, 10.01, 10.01, 10.02, 10.09, 9.59, 9.39, 9.60, 9.57, 9.50,
-        9.45, 9.35, 9.33, 9.13, 9.27, 9.26, 9.34, 9.38, 9.35, 9.21, 9.17, 9.06,
-        8.97, 8.96, 9.00, 9.10, 9.24, 9.04, 8.92, 9.09, 9.15, 9.31, 9.35, 9.34,
-        9.35, 9.40, 9.44, 9.49, 9.59, 9.63, 9.63, 9.53, 9.49, 9.45, 9.49, 9.39,
-        9.34, 9.32, 9.31, 9.34, 9.41, 9.57, 9.92, 10.14, 10.11, 10.15, 10.21,
-        10.34, 10.53, 10.39, 10.42, 10.59, 10.44, 10.40, 10.32, 10.09, 10.01,
-        10.02, 9.86, 9.93, 9.79, 9.94, 10.11, 10.16, 10.05, 10.10, 9.98, 10.14,
-        10.12, 10.22, 10.30, 10.41, 10.43, 10.18, 10.17, 10.00, 10.17, 10.39,
-        10.36, 11.16, 11.25, 11.17, 11.25, 11.42, 11.06, 10.90, 10.93, 10.97,
-        11.00, 10.67, 10.57, 10.50, 10.83, 10.85, 10.92, 11.10, 11.11, 11.10,
-        11.25, 11.53, 11.45, 11.41, 11.31, 11.31, 11.24, 11.48, 11.47, 11.49,
-        11.47, 11.27, 11.10, 11.39, 11.67, 11.73, 11.77, 11.86, 12.40, 12.79,
-        12.76, 12.87, 12.95, ]),
-
-    'volume': np.asarray([ 45709900, 79725200, 67877500, 59840700, 53981500,
-        121750600, 63806000, 48687700, 46366700, 44398400, 47102700, 70894200,
-        43705700, 49379700, 45768400, 54021600, 75470700, 142155300, 57752600,
-        46412100, 71669000, 48347600, 78851200, 46363300, 39413500, 35352500,
-        52290500, 52505500, 34474400, 39627900, 38174800, 49164400, 30778000,
-        38409800, 43326000, 36747600, 31399300, 38703400, 30789000, 62093700,
-        68262000, 49063500, 28433700, 57374500, 28440900, 37099100, 36159300,
-        30275700, 42783600, 47578500, 55286600, 77119600, 52445700, 40214400,
-        27521400, 50117100, 44755000, 26692200, 35070700, 41051700, 51039700,
-        36381000, 43966900, 97034200, 51505000, 37939500, 42515300, 77370300,
-        34724400, 26988800, 39675000, 31903500, 35981200, 32314000, 48169200,
-        52631000, 31269200, 38615200, 45185400, 40889300, 83070300, 46156300,
-        43959200, 48572900, 40238400, 53268400, 33235200, 46174500, 54501200,
-        42526100, 36561300, 50225200, 41886500, 44321300, 49648900, 50572000,
-        38134900, 44295700, 75647800, 45334100, 30430800, 43760600, 44592100,
-        54297000, 68237000, 57305600, 38326200, 50458000, 33846100, 30811600,
-        35811400, 35130800, 53471900, 37531800, 39442000, 27361000, 37155900,
-        40810100, 40062800, 56427300, 44297600, 31871900, 33278900, 38648400,
-        138138600, 63388600, 49629300, 31783900, 30355400, 37441600, 33516600,
-        32028700, 55111000, 30248300, 28838200, 29510000, 31010000, 33615000,
-        27968300, 33773800, 53519200, 44338200, 51798900, 67986800, 40958300,
-        41360900, 65973000, 45326500, 38631400, 23819100, 43574500, 22630300,
-        30909800, 19618800, 21122000, 21129500, 21308300, 34323700, 34533900,
-        38923800, 26281100, 26965500, 23537700, 19574600, 22754200, 23084400,
-        26115700, 16459400, 28029200, 37965000, 40608800, 67996400, 60617000,
-        43381300, 28165300, 28046500, 50920200, 55934300, 31922200, 34937000,
-        42403000, 28755100, 35459800, 28557900, 36866300, 44362600, 25740900,
-        44586300, 33445600, 63630000, 51023800, 46855500, 40693900, 25473900,
-        38235700, 33951600, 39328700, 24108500, 26466500, 32788400, 29346300,
-        44041700, 40493000, 39149700, 32476500, 49339800, 59290900, 43485500,
-        137960900, 88770100, 53399000, 37995000, 51232200, 56674900, 45948800,
-        40703600, 25723100, 33342900, 45664700, 48879800, 45346200, 39359100,
-        34739800, 21181700, 16032200, 26831700, 37610000, 38496900, 57289300,
-        41329600, 47746300, 37760200, 33152400, 31065800, 38404500, 26025200,
-        36326900, 31099900, 35443200, 36933500, 46983300, 61810400, 54884700,
-        47750100, 94489300, 91734900, 140331900, 108315100, 95668600, 106908900 ]),
-    }
-
-series = np.array([ 91.50, 94.81, 94.38, 95.09, 93.78, 94.62, 92.53, 92.75,
-     90.31, 92.47, 96.12, 97.25, 98.50, 89.88, 91.00, 92.81, 89.16, 89.34,
-     91.62, 89.88, 88.38, 87.62, 84.78, 83.00, 83.50, 81.38, 84.44, 89.25,
-     86.38, 86.25, 85.25, 87.12, 85.81, 88.97, 88.47, 86.88, 86.81, 84.88,
-     84.19, 83.88, 83.38, 85.50, 89.19, 89.44, 91.09, 90.75, 91.44, 89.00,
-     91.00, 90.50, 89.03, 88.81, 84.28, 83.50, 82.69, 84.75, 85.66, 86.19,
-     88.94, 89.28, 88.62, 88.50, 91.97, 91.50, 93.25, 93.50, 93.16, 91.72,
-     90.00, 89.69, 88.88, 85.19, 83.38, 84.88, 85.94, 97.25, 99.88, 104.94,
-     106.00, 102.50, 102.41, 104.59, 106.12, 106.00, 106.06, 104.62, 108.62,
-     109.31, 110.50, 112.75, 123.00, 119.62, 118.75, 119.25, 117.94, 116.44,
-     115.19, 111.88, 110.59, 118.12, 116.00, 116.00, 112.00, 113.75, 112.94,
-     116.00, 120.50, 116.62, 117.00, 115.25, 114.31, 115.50, 115.87, 120.69,
-     120.19, 120.75, 124.75, 123.37, 122.94, 122.56, 123.12, 122.56, 124.62,
-     129.25, 131.00, 132.25, 131.00, 132.81, 134.00, 137.38, 137.81, 137.88,
-     137.25, 136.31, 136.25, 134.63, 128.25, 129.00, 123.87, 124.81, 123.00,
-     126.25, 128.38, 125.37, 125.69, 122.25, 119.37, 118.50, 123.19, 123.50,
-     122.19, 119.31, 123.31, 121.12, 123.37, 127.37, 128.50, 123.87, 122.94,
-     121.75, 124.44, 122.00, 122.37, 122.94, 124.00, 123.19, 124.56, 127.25,
-     125.87, 128.86, 132.00, 130.75, 134.75, 135.00, 132.38, 133.31, 131.94,
-     130.00, 125.37, 130.13, 127.12, 125.19, 122.00, 125.00, 123.00, 123.50,
-     120.06, 121.00, 117.75, 119.87, 122.00, 119.19, 116.37, 113.50, 114.25,
-     110.00, 105.06, 107.00, 107.87, 107.00, 107.12, 107.00, 91.00, 93.94,
-     93.87, 95.50, 93.00, 94.94, 98.25, 96.75, 94.81, 94.37, 91.56, 90.25,
-     93.94, 93.62, 97.00, 95.00, 95.87, 94.06, 94.62, 93.75, 98.00, 103.94,
-     107.87, 106.06, 104.50, 105.00, 104.19, 103.06, 103.42, 105.27, 111.87,
-     116.00, 116.62, 118.28, 113.37, 109.00, 109.70, 109.25, 107.00, 109.19,
-     110.00, 109.20, 110.12, 108.00, 108.62, 109.75, 109.81, 109.00, 108.75,
-     107.87 ])
-
-def assert_np_arrays_equal(expected, got):
-    for i, value in enumerate(expected):
-        if np.isnan(value):
-            assert_true(np.isnan(got[i]))
-        else:
-            assert_equal(value, got[i])
-
-def assert_np_arrays_not_equal(expected, got):
-    ''' Verifies expected and got have the same number of leading nan fields,
-    followed by different floats.
-    '''
-    nans = []
-    equals = []
-    for i, value in enumerate(expected):
-        if np.isnan(value):
-            assert_true(np.isnan(got[i]))
-            nans.append(value)
-        else:
-            try:
-                assert_not_equal(value, got[i])
-            except AssertionError:
-                equals.append(got[i])
-    if len(equals) == len(expected[len(nans):]):
-        raise AssertionError('Arrays were equal.')
-    elif equals:
-        print('Arrays had %i/%i equivalent values.' % (len(equals), len(expected[len(nans):])))
diff --git a/talib/test_func.py b/talib/test_func.py
deleted file mode 100644
index 6bf45f077..000000000
--- a/talib/test_func.py
+++ /dev/null
@@ -1,158 +0,0 @@
-import numpy as np
-from nose.tools import assert_equals, assert_true, assert_raises
-
-import talib
-from talib import func
-from talib.test_data import series, assert_np_arrays_equal, assert_np_arrays_not_equal
-
-def test_talib_version():
-    assert_equals(talib.__ta_version__[:5], b'0.4.0')
-
-def test_num_functions():
-    assert_equals(len(talib.get_functions()), 158)
-
-def test_input_wrong_type():
-    a1 = np.arange(10, dtype=int)
-    with assert_raises(Exception):
-        func.MOM(a1)
-
-def test_input_lengths():
-    a1 = np.arange(10, dtype=float)
-    a2 = np.arange(11, dtype=float)
-    with assert_raises(Exception):
-        func.BOP(a2, a1, a1, a1)
-    with assert_raises(Exception):
-        func.BOP(a1, a2, a1, a1)
-    with assert_raises(Exception):
-        func.BOP(a1, a1, a2, a1)
-    with assert_raises(Exception):
-        func.BOP(a1, a1, a1, a2)
-
-def test_input_nans():
-    a1 = np.arange(10, dtype=float)
-    a2 = np.arange(10, dtype=float)
-    a2[0] = np.nan
-    a2[1] = np.nan
-    r1, r2 = func.AROON(a1, a2, 2)
-    assert_np_arrays_equal(r1, [np.nan, np.nan, np.nan, np.nan, 0, 0, 0, 0, 0, 0])
-    assert_np_arrays_equal(r2, [np.nan, np.nan, np.nan, np.nan, 100, 100, 100, 100, 100, 100])
-    r1, r2 = func.AROON(a2, a1, 2)
-    assert_np_arrays_equal(r1, [np.nan, np.nan, np.nan, np.nan, 0, 0, 0, 0, 0, 0])
-    assert_np_arrays_equal(r2, [np.nan, np.nan, np.nan, np.nan, 100, 100, 100, 100, 100, 100])
-
-def test_unstable_period():
-    a = np.arange(10, dtype=float)
-    r = func.EMA(a, 3)
-    assert_np_arrays_equal(r, [np.nan, np.nan, 1, 2, 3, 4, 5, 6, 7, 8])
-    talib.set_unstable_period('EMA', 5)
-    r = func.EMA(a, 3)
-    assert_np_arrays_equal(r, [np.nan, np.nan, np.nan, np.nan, np.nan, np.nan, np.nan, 6, 7, 8])
-    talib.set_unstable_period('EMA', 0)
-
-def test_compatibility():
-    a = np.arange(10, dtype=float)
-    talib.set_compatibility(0)
-    r = func.EMA(a, 3)
-    assert_np_arrays_equal(r, [np.nan, np.nan, 1, 2, 3, 4, 5, 6, 7, 8])
-    talib.set_compatibility(1)
-    r = func.EMA(a, 3)
-    assert_np_arrays_equal(r, [np.nan, np.nan,1.25,2.125,3.0625,4.03125,5.015625,6.0078125,7.00390625,8.001953125])
-    talib.set_compatibility(0)
-
-def test_MIN():
-    result = func.MIN(series, timeperiod=4)
-    i = np.where(~np.isnan(result))[0][0]
-    assert_equals(len(series), len(result))
-    assert_equals(result[i + 1], 93.780)
-    assert_equals(result[i + 2], 93.780)
-    assert_equals(result[i + 3], 92.530)
-    assert_equals(result[i + 4], 92.530)
-    values = np.array([np.nan, 5., 4., 3., 5., 7.])
-    result = func.MIN(values, timeperiod=2)
-    assert_np_arrays_equal(result, [np.nan, np.nan, 4, 3, 3, 5])
-
-def test_MAX():
-    result = func.MAX(series, timeperiod=4)
-    i = np.where(~np.isnan(result))[0][0]
-    assert_equals(len(series), len(result))
-    assert_equals(result[i + 2], 95.090)
-    assert_equals(result[i + 3], 95.090)
-    assert_equals(result[i + 4], 94.620)
-    assert_equals(result[i + 5], 94.620)
-
-def test_MOM():
-    values = np.array([90.0,88.0,89.0])
-    result = func.MOM(values, timeperiod=1)
-    assert_np_arrays_equal(result, [np.nan, -2, 1])
-    result = func.MOM(values, timeperiod=2)
-    assert_np_arrays_equal(result, [np.nan, np.nan, -1])
-    result = func.MOM(values, timeperiod=3)
-    assert_np_arrays_equal(result, [np.nan, np.nan, np.nan])
-    result = func.MOM(values, timeperiod=4)
-    assert_np_arrays_equal(result, [np.nan, np.nan, np.nan])
-
-def test_BBANDS():
-    upper, middle, lower = func.BBANDS(series, timeperiod=20,
-                                        nbdevup=2.0, nbdevdn=2.0,
-                                        matype=talib.MA_Type.EMA)
-    i = np.where(~np.isnan(upper))[0][0]
-    assert_true(len(upper) == len(middle) == len(lower) == len(series))
-    #assert_true(abs(upper[i + 0] - 98.0734) < 1e-3)
-    assert_true(abs(middle[i + 0] - 92.8910) < 1e-3)
-    assert_true(abs(lower[i + 0] - 87.7086) < 1e-3)
-    #assert_true(abs(upper[i + 13] - 93.674) < 1e-3)
-    assert_true(abs(middle[i + 13] - 87.679) < 1e-3)
-    assert_true(abs(lower[i + 13] - 81.685) < 1e-3)
-
-def test_DEMA():
-    result = func.DEMA(series)
-    i = np.where(~np.isnan(result))[0][0]
-    assert_true(len(series) == len(result))
-    assert_true(abs(result[i + 1] - 86.765) < 1e-3)
-    assert_true(abs(result[i + 2] - 86.942) < 1e-3)
-    assert_true(abs(result[i + 3] - 87.089) < 1e-3)
-    assert_true(abs(result[i + 4] - 87.656) < 1e-3)
-
-def test_EMAEMA():
-    result = func.EMA(series, timeperiod=2)
-    result = func.EMA(result, timeperiod=2)
-    i = np.where(~np.isnan(result))[0][0]
-    assert_true(len(series) == len(result))
-    assert_equals(i, 2)
-
-def test_CDL3BLACKCROWS():
-    o = np.array([39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 40.32, 40.51, 38.09, 35.00, 27.66, 30.80])
-    h = np.array([40.84, 40.84, 40.84, 40.84, 40.84, 40.84, 40.84, 40.84, 40.84, 40.84, 40.84, 40.84, 40.84, 40.84, 41.69, 40.84, 38.12, 35.50, 31.74, 32.51])
-    l = np.array([35.80, 35.80, 35.80, 35.80, 35.80, 35.80, 35.80, 35.80, 35.80, 35.80, 35.80, 35.80, 35.80, 35.80, 39.26, 36.73, 33.37, 30.03, 27.03, 28.31])
-    c = np.array([40.29, 40.29, 40.29, 40.29, 40.29, 40.29, 40.29, 40.29, 40.29, 40.29, 40.29, 40.29, 40.29, 40.29, 40.46, 37.08, 33.37, 30.03, 31.46, 28.31])
-
-    result = func.CDL3BLACKCROWS(o, h, l, c)
-    assert_np_arrays_equal(result, [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -100, 0, 0])
-
-def test_RSI():
-    a = np.array([0.00000024, 0.00000024, 0.00000024,
-      0.00000024, 0.00000024, 0.00000023,
-      0.00000024, 0.00000024, 0.00000024,
-      0.00000024, 0.00000023, 0.00000024,
-      0.00000023, 0.00000024, 0.00000023,
-      0.00000024, 0.00000024, 0.00000023,
-      0.00000023, 0.00000023], dtype='float64')
-    result = func.RSI(a, 10)
-    assert_np_arrays_equal(result, [np.nan,np.nan,np.nan,np.nan,np.nan,np.nan,np.nan,np.nan,np.nan,np.nan,0,0,0,0,0,0,0,0,0,0])
-    result = func.RSI(a * 100000, 10)
-    assert_np_arrays_equal(result, [np.nan,np.nan,np.nan,np.nan,np.nan,np.nan,np.nan,np.nan,np.nan,np.nan,33.333333333333329,51.351351351351347,39.491916859122398,51.84807024709005,42.25953803191981,52.101824405061215,52.101824405061215,43.043664867691085,43.043664867691085,43.043664867691085])
-
-def test_MAVP():
-    a = np.array([1,5,3,4,7,3,8,1,4,6], dtype=float)
-    b = np.array([2,4,2,4,2,4,2,4,2,4], dtype=float)
-    result = func.MAVP(a, b, minperiod=2, maxperiod=4)
-    assert_np_arrays_equal(result, [np.nan,np.nan,np.nan,3.25,5.5,4.25,5.5,4.75,2.5,4.75])
-    sma2 = func.SMA(a, 2)
-    assert_np_arrays_equal(result[4::2], sma2[4::2])
-    sma4 = func.SMA(a, 4)
-    assert_np_arrays_equal(result[3::2], sma4[3::2])
-    result = func.MAVP(a, b, minperiod=2, maxperiod=3)
-    assert_np_arrays_equal(result, [np.nan,np.nan,4,4,5.5,4.666666666666667,5.5,4,2.5,3.6666666666666665])
-    sma3 = func.SMA(a, 3)
-    assert_np_arrays_equal(result[2::2], sma2[2::2])
-    assert_np_arrays_equal(result[3::2], sma3[3::2])
diff --git a/talib/test_pandas.py b/talib/test_pandas.py
deleted file mode 100644
index 7c9e8d3bd..000000000
--- a/talib/test_pandas.py
+++ /dev/null
@@ -1,50 +0,0 @@
-import numpy as np
-import pandas as pd
-from nose.tools import assert_equals, assert_is_instance, assert_true
-
-import talib
-from talib.test_data import series, assert_np_arrays_equal
-
-def test_MOM():
-    values = pd.Series([90.0,88.0,89.0], index=[10, 20, 30])
-    result = talib.MOM(values, timeperiod=1)
-    assert_is_instance(result, pd.Series)
-    assert_np_arrays_equal(result.values, [np.nan, -2, 1])
-    assert_np_arrays_equal(result.index, [10, 20, 30])
-    result = talib.MOM(values, timeperiod=2)
-    assert_is_instance(result, pd.Series)
-    assert_np_arrays_equal(result.values, [np.nan, np.nan, -1])
-    assert_np_arrays_equal(result.index, [10, 20, 30])
-    result = talib.MOM(values, timeperiod=3)
-    assert_is_instance(result, pd.Series)
-    assert_np_arrays_equal(result.values, [np.nan, np.nan, np.nan])
-    assert_np_arrays_equal(result.index, [10, 20, 30])
-    result = talib.MOM(values, timeperiod=4)
-    assert_is_instance(result, pd.Series)
-    assert_np_arrays_equal(result.values, [np.nan, np.nan, np.nan])
-    assert_np_arrays_equal(result.index, [10, 20, 30])
-
-def test_MAVP():
-    a = pd.Series([1,5,3,4,7,3,8,1,4,6], index=range(10, 20), dtype=float)
-    b = pd.Series([2,4,2,4,2,4,2,4,2,4], index=range(20, 30), dtype=float)
-    result = talib.MAVP(a, b, minperiod=2, maxperiod=4)
-    assert_is_instance(result, pd.Series)
-    assert_np_arrays_equal(result.values, [np.nan,np.nan,np.nan,3.25,5.5,4.25,5.5,4.75,2.5,4.75])
-    assert_np_arrays_equal(result.index, range(10, 20))
-    sma2 = talib.SMA(a, 2)
-    assert_is_instance(sma2, pd.Series)
-    assert_np_arrays_equal(sma2.index, range(10, 20))
-    assert_np_arrays_equal(result.values[4::2], sma2.values[4::2])
-    sma4 = talib.SMA(a, 4)
-    assert_is_instance(sma4, pd.Series)
-    assert_np_arrays_equal(sma4.index, range(10, 20))
-    assert_np_arrays_equal(result.values[3::2], sma4.values[3::2])
-    result = talib.MAVP(a, b, minperiod=2, maxperiod=3)
-    assert_is_instance(result, pd.Series)
-    assert_np_arrays_equal(result.values, [np.nan,np.nan,4,4,5.5,4.666666666666667,5.5,4,2.5,3.6666666666666665])
-    assert_np_arrays_equal(result.index, range(10, 20))
-    sma3 = talib.SMA(a, 3)
-    assert_is_instance(sma3, pd.Series)
-    assert_np_arrays_equal(sma3.index, range(10, 20))
-    assert_np_arrays_equal(result.values[2::2], sma2.values[2::2])
-    assert_np_arrays_equal(result.values[3::2], sma3.values[3::2])
diff --git a/talib/test_stream.py b/talib/test_stream.py
deleted file mode 100644
index 0abd8dc78..000000000
--- a/talib/test_stream.py
+++ /dev/null
@@ -1,31 +0,0 @@
-import numpy as np
-from nose.tools import assert_equals, assert_true, assert_raises
-
-import talib
-from talib import stream
-
-def test_streaming():
-    a = np.array([1,1,2,3,5,8,13], dtype=float)
-    r = stream.MOM(a, timeperiod=1)
-    assert_equals(r, 5)
-    r = stream.MOM(a, timeperiod=2)
-    assert_equals(r, 8)
-    r = stream.MOM(a, timeperiod=3)
-    assert_equals(r, 10)
-    r = stream.MOM(a, timeperiod=4)
-    assert_equals(r, 11)
-    r = stream.MOM(a, timeperiod=5)
-    assert_equals(r, 12)
-    r = stream.MOM(a, timeperiod=6)
-    assert_equals(r, 12)
-    r = stream.MOM(a, timeperiod=7)
-    assert_true(np.isnan(r))
-
-def test_CDL3BLACKCROWS():
-    o = np.array([39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 40.32, 40.51, 38.09, 35.00])
-    h = np.array([40.84, 40.84, 40.84, 40.84, 40.84, 40.84, 40.84, 40.84, 40.84, 40.84, 40.84, 40.84, 40.84, 40.84, 41.69, 40.84, 38.12, 35.50])
-    l = np.array([35.80, 35.80, 35.80, 35.80, 35.80, 35.80, 35.80, 35.80, 35.80, 35.80, 35.80, 35.80, 35.80, 35.80, 39.26, 36.73, 33.37, 30.03])
-    c = np.array([40.29, 40.29, 40.29, 40.29, 40.29, 40.29, 40.29, 40.29, 40.29, 40.29, 40.29, 40.29, 40.29, 40.29, 40.46, 37.08, 33.37, 30.03])
-
-    r = stream.CDL3BLACKCROWS(o, h, l, c)
-    assert_equals(r, -100)
diff --git a/tests/conftest.py b/tests/conftest.py
new file mode 100644
index 000000000..03a8f9481
--- /dev/null
+++ b/tests/conftest.py
@@ -0,0 +1,242 @@
+import pytest
+import numpy as np
+
+
+@pytest.fixture(scope='session')
+def ford_2012_dates():
+    return np.asarray([
+        20120103, 20120104, 20120105, 20120106, 20120109,
+        20120110, 20120111, 20120112, 20120113, 20120117, 20120118, 20120119,
+        20120120, 20120123, 20120124, 20120125, 20120126, 20120127, 20120130,
+        20120131, 20120201, 20120202, 20120203, 20120206, 20120207, 20120208,
+        20120209, 20120210, 20120213, 20120214, 20120215, 20120216, 20120217,
+        20120221, 20120222, 20120223, 20120224, 20120227, 20120228, 20120229,
+        20120301, 20120302, 20120305, 20120306, 20120307, 20120308, 20120309,
+        20120312, 20120313, 20120314, 20120315, 20120316, 20120319, 20120320,
+        20120321, 20120322, 20120323, 20120326, 20120327, 20120328, 20120329,
+        20120330, 20120402, 20120403, 20120404, 20120405, 20120409, 20120410,
+        20120411, 20120412, 20120413, 20120416, 20120417, 20120418, 20120419,
+        20120420, 20120423, 20120424, 20120425, 20120426, 20120427, 20120430,
+        20120501, 20120502, 20120503, 20120504, 20120507, 20120508, 20120509,
+        20120510, 20120511, 20120514, 20120515, 20120516, 20120517, 20120518,
+        20120521, 20120522, 20120523, 20120524, 20120525, 20120529, 20120530,
+        20120531, 20120601, 20120604, 20120605, 20120606, 20120607, 20120608,
+        20120611, 20120612, 20120613, 20120614, 20120615, 20120618, 20120619,
+        20120620, 20120621, 20120622, 20120625, 20120626, 20120627, 20120628,
+        20120629, 20120702, 20120703, 20120705, 20120706, 20120709, 20120710,
+        20120711, 20120712, 20120713, 20120716, 20120717, 20120718, 20120719,
+        20120720, 20120723, 20120724, 20120725, 20120726, 20120727, 20120730,
+        20120731, 20120801, 20120802, 20120803, 20120806, 20120807, 20120808,
+        20120809, 20120810, 20120813, 20120814, 20120815, 20120816, 20120817,
+        20120820, 20120821, 20120822, 20120823, 20120824, 20120827, 20120828,
+        20120829, 20120830, 20120831, 20120904, 20120905, 20120906, 20120907,
+        20120910, 20120911, 20120912, 20120913, 20120914, 20120917, 20120918,
+        20120919, 20120920, 20120921, 20120924, 20120925, 20120926, 20120927,
+        20120928, 20121001, 20121002, 20121003, 20121004, 20121005, 20121008,
+        20121009, 20121010, 20121011, 20121012, 20121015, 20121016, 20121017,
+        20121018, 20121019, 20121022, 20121023, 20121024, 20121025, 20121026,
+        20121031, 20121101, 20121102, 20121105, 20121106, 20121107, 20121108,
+        20121109, 20121112, 20121113, 20121114, 20121115, 20121116, 20121119,
+        20121120, 20121121, 20121123, 20121126, 20121127, 20121128, 20121129,
+        20121130, 20121203, 20121204, 20121205, 20121206, 20121207, 20121210,
+        20121211, 20121212, 20121213, 20121214, 20121217, 20121218, 20121219,
+        20121220, 20121221, 20121224, 20121226, 20121227, 20121228, 20121231
+    ])
+
+
+@pytest.fixture(scope='session')
+def ford_2012():
+    return {
+        'open': np.asarray([
+            11.00, 11.15, 11.33, 11.74, 11.83, 12.00, 11.74, 12.16, 12.01,
+            12.20, 12.03, 12.48, 12.55, 12.69, 12.56, 12.80, 13.03, 11.96,
+            12.06, 12.47, 12.73, 12.40, 12.47, 12.85, 12.93, 12.91, 12.89,
+            12.52, 12.74, 12.46, 12.47, 12.38, 12.84, 12.74, 12.49, 12.27,
+            12.43, 12.11, 12.34, 12.28, 12.48, 12.74, 12.67, 12.23, 12.21,
+            12.41, 12.53, 12.57, 12.48, 12.64, 12.90, 12.86, 12.52, 12.48,
+            12.59, 12.48, 12.31, 12.45, 12.51, 12.35, 12.33, 12.55, 12.50,
+            12.71, 12.46, 12.38, 12.26, 12.19, 11.99, 11.94, 11.98, 12.01,
+            11.98, 11.81, 11.81, 11.71, 11.15, 11.61, 11.51, 11.71, 12.03,
+            11.42, 11.25, 11.16, 11.13, 10.84, 10.53, 10.60, 10.48, 10.83,
+            10.61, 10.41, 10.34, 10.23, 10.16, 10.08, 10.02, 10.25, 10.32,
+            10.50, 10.61, 10.69, 10.73, 10.62, 10.33, 10.15, 10.01, 10.29,
+            10.73, 10.48, 10.77, 10.47, 10.39, 10.27, 10.40, 10.35, 10.37,
+            10.58, 10.65, 10.35, 10.13, 10.06, 10.05, 9.93, 9.95, 9.50, 9.53,
+            9.67, 9.47, 9.46, 9.50, 9.33, 9.26, 9.16, 9.22, 9.28, 9.38, 9.45,
+            9.28, 9.08, 9.17, 9.17, 9.05, 8.99, 9.04, 9.13, 9.29, 8.99, 9.02,
+            9.13, 9.18, 9.25, 9.31, 9.30, 9.35, 9.45, 9.44, 9.50, 9.65, 9.58,
+            9.65, 9.50, 9.45, 9.42, 9.51, 9.37, 9.33, 9.30, 9.39, 9.37, 9.45,
+            9.66, 9.95, 10.08, 10.18, 10.25, 10.20, 10.41, 10.27, 10.30, 10.49,
+            10.48, 10.53, 10.30, 10.35, 9.98, 10.13, 9.99, 9.89, 10.01, 9.82,
+            10.06, 10.17, 10.06, 10.21, 10.12, 10.06, 10.14, 10.11, 10.26,
+            10.31, 10.36, 10.42, 10.14, 10.02, 10.08, 10.42, 10.35, 10.70,
+            11.19, 11.31, 11.15, 11.33, 11.25, 11.07, 10.76, 11.03, 10.89,
+            11.02, 10.57, 10.58, 10.65, 10.85, 10.84, 10.98, 11.05, 11.10,
+            11.05, 11.32, 11.52, 11.56, 11.40, 11.32, 11.26, 11.27, 11.41,
+            11.51, 11.52, 11.46, 11.27, 11.16, 11.48, 11.79, 11.74, 11.55,
+            11.67, 12.31, 12.79, 12.55, 12.88
+        ]),
+        'high': np.asarray([
+            11.25, 11.53, 11.63, 11.80, 11.95, 12.05, 12.18, 12.18, 12.08,
+            12.26, 12.37, 12.72, 12.64, 12.84, 12.86, 12.98, 13.05, 12.53,
+            12.44, 12.51, 12.75, 12.43, 12.84, 13.00, 12.97, 12.96, 12.90,
+            12.66, 12.74, 12.58, 12.57, 12.77, 12.88, 12.76, 12.51, 12.44,
+            12.46, 12.36, 12.35, 12.55, 12.77, 12.94, 12.68, 12.25, 12.30,
+            12.55, 12.73, 12.59, 12.72, 12.90, 13.04, 12.90, 12.68, 12.61,
+            12.67, 12.54, 12.37, 12.50, 12.61, 12.36, 12.52, 12.58, 12.65,
+            12.95, 12.52, 12.58, 12.29, 12.28, 12.02, 12.13, 12.03, 12.05,
+            12.00, 11.85, 11.88, 11.72, 11.40, 11.61, 11.75, 11.93, 12.04,
+            11.47, 11.34, 11.17, 11.15, 10.87, 10.79, 10.64, 10.81, 10.86,
+            10.83, 10.53, 10.34, 10.43, 10.25, 10.18, 10.23, 10.40, 10.45,
+            10.62, 10.68, 10.88, 10.75, 10.68, 10.37, 10.18, 10.24, 10.58,
+            10.78, 10.68, 10.80, 10.55, 10.49, 10.45, 10.42, 10.40, 10.64,
+            10.74, 10.68, 10.40, 10.18, 10.08, 10.10, 10.09, 9.98, 9.60, 9.79,
+            9.74, 9.52, 9.47, 9.55, 9.38, 9.28, 9.32, 9.32, 9.35, 9.52, 9.50,
+            9.35, 9.21, 9.24, 9.20, 9.11, 9.10, 9.18, 9.28, 9.42, 9.03, 9.15,
+            9.21, 9.39, 9.38, 9.46, 9.36, 9.42, 9.66, 9.54, 9.67, 9.66, 9.64,
+            9.70, 9.56, 9.54, 9.52, 9.52, 9.44, 9.40, 9.34, 9.43, 9.47, 9.62,
+            9.96, 10.23, 10.28, 10.25, 10.30, 10.38, 10.57, 10.42, 10.45, 10.66,
+            10.52, 10.54, 10.40, 10.37, 10.12, 10.18, 10.00, 10.08, 10.05,
+            10.02, 10.15, 10.28, 10.12, 10.25, 10.12, 10.26, 10.25, 10.25,
+            10.32, 10.41, 10.57, 10.43, 10.24, 10.11, 10.29, 10.49, 10.42,
+            11.17, 11.30, 11.38, 11.35, 11.59, 11.34, 11.23, 11.10, 11.16,
+            11.10, 11.05, 10.80, 10.64, 10.90, 11.02, 11.00, 11.10, 11.14,
+            11.27, 11.26, 11.53, 11.60, 11.70, 11.44, 11.40, 11.31, 11.50,
+            11.53, 11.58, 11.56, 11.50, 11.27, 11.41, 11.68, 11.85, 11.80,
+            11.86, 12.40, 12.79, 12.81, 12.88, 13.08
+        ]),
+        'low': np.asarray([
+            10.99, 11.07, 11.24, 11.52, 11.70, 11.63, 11.65, 11.89, 11.84,
+            11.96, 12.00, 12.43, 12.45, 12.55, 12.46, 12.70, 12.66, 11.79,
+            12.00, 12.20, 12.29, 12.20, 12.39, 12.71, 12.83, 12.80, 12.67,
+            12.37, 12.51, 12.34, 12.33, 12.38, 12.71, 12.46, 12.22, 12.16,
+            12.19, 11.99, 12.20, 12.25, 12.45, 12.68, 12.41, 12.00, 12.15,
+            12.32, 12.48, 12.37, 12.40, 12.63, 12.83, 12.51, 12.48, 12.39,
+            12.55, 12.24, 12.18, 12.39, 12.30, 12.18, 12.24, 12.40, 12.44,
+            12.46, 12.32, 12.38, 12.11, 11.65, 11.88, 11.86, 11.84, 11.83,
+            11.88, 11.72, 11.58, 11.39, 11.15, 11.36, 11.43, 11.67, 11.52,
+            11.15, 11.11, 11.00, 10.85, 10.63, 10.52, 10.40, 10.41, 10.66,
+            10.56, 10.30, 10.10, 10.15, 10.01, 9.96, 10.00, 10.15, 10.22, 10.38,
+            10.51, 10.68, 10.52, 10.40, 10.06, 9.91, 9.97, 10.27, 10.52, 10.38,
+            10.45, 10.31, 10.22, 10.21, 10.26, 10.26, 10.35, 10.52, 10.25,
+            10.18, 9.95, 9.96, 9.97, 9.93, 9.46, 9.30, 9.49, 9.53, 9.40, 9.31,
+            9.28, 9.26, 9.12, 9.14, 9.15, 9.12, 9.34, 9.33, 9.18, 9.05, 8.95,
+            8.91, 8.83, 8.88, 9.01, 9.12, 8.99, 8.82, 8.96, 9.09, 9.18, 9.24,
+            9.30, 9.23, 9.25, 9.42, 9.41, 9.49, 9.60, 9.51, 9.52, 9.40, 9.42,
+            9.41, 9.38, 9.31, 9.29, 9.25, 9.31, 9.35, 9.39, 9.66, 9.93, 10.06,
+            10.13, 10.17, 10.12, 10.39, 10.26, 10.28, 10.45, 10.35, 10.36,
+            10.26, 10.06, 9.86, 10.02, 9.81, 9.88, 9.71, 9.76, 9.96, 10.13,
+            9.99, 10.02, 9.95, 10.05, 10.09, 10.09, 10.22, 10.26, 10.33, 10.13,
+            10.03, 9.97, 10.01, 10.28, 10.22, 10.60, 10.88, 11.15, 11.13, 11.26,
+            11.04, 10.89, 10.71, 10.96, 10.86, 10.62, 10.46, 10.38, 10.65,
+            10.76, 10.80, 10.96, 10.97, 11.10, 10.98, 11.32, 11.33, 11.40,
+            11.23, 11.18, 11.19, 11.26, 11.41, 11.40, 11.43, 11.21, 11.03,
+            11.14, 11.40, 11.62, 11.58, 11.47, 11.67, 12.31, 12.36, 12.52, 12.76
+        ]),
+        'close': np.asarray([
+            11.13, 11.30, 11.59, 11.71, 11.80, 11.80, 12.07, 12.14, 12.04,
+            12.02, 12.34, 12.61, 12.59, 12.66, 12.82, 12.93, 12.79, 12.21,
+            12.29, 12.42, 12.33, 12.26, 12.79, 12.96, 12.88, 12.84, 12.69,
+            12.44, 12.54, 12.48, 12.38, 12.74, 12.75, 12.53, 12.28, 12.40,
+            12.23, 12.30, 12.25, 12.38, 12.66, 12.72, 12.46, 12.09, 12.24,
+            12.46, 12.58, 12.43, 12.70, 12.88, 12.90, 12.51, 12.63, 12.54,
+            12.57, 12.32, 12.32, 12.48, 12.32, 12.32, 12.50, 12.48, 12.62,
+            12.64, 12.51, 12.47, 12.22, 11.79, 11.91, 12.07, 11.92, 11.88,
+            11.91, 11.79, 11.66, 11.41, 11.35, 11.39, 11.73, 11.87, 11.60,
+            11.28, 11.23, 11.10, 10.92, 10.67, 10.66, 10.61, 10.69, 10.71,
+            10.58, 10.32, 10.15, 10.16, 10.01, 10.01, 10.20, 10.19, 10.41,
+            10.59, 10.60, 10.84, 10.66, 10.56, 10.12, 10.04, 10.19, 10.57,
+            10.55, 10.66, 10.45, 10.50, 10.30, 10.41, 10.35, 10.34, 10.56,
+            10.65, 10.27, 10.19, 10.01, 10.01, 10.02, 10.09, 9.59, 9.39, 9.60,
+            9.57, 9.50, 9.45, 9.35, 9.33, 9.13, 9.27, 9.26, 9.34, 9.38, 9.35,
+            9.21, 9.17, 9.06, 8.97, 8.96, 9.00, 9.10, 9.24, 9.04, 8.92, 9.09,
+            9.15, 9.31, 9.35, 9.34, 9.35, 9.40, 9.44, 9.49, 9.59, 9.63, 9.63,
+            9.53, 9.49, 9.45, 9.49, 9.39, 9.34, 9.32, 9.31, 9.34, 9.41, 9.57,
+            9.92, 10.14, 10.11, 10.15, 10.21, 10.34, 10.53, 10.39, 10.42, 10.59,
+            10.44, 10.40, 10.32, 10.09, 10.01, 10.02, 9.86, 9.93, 9.79, 9.94,
+            10.11, 10.16, 10.05, 10.10, 9.98, 10.14, 10.12, 10.22, 10.30, 10.41,
+            10.43, 10.18, 10.17, 10.00, 10.17, 10.39, 10.36, 11.16, 11.25,
+            11.17, 11.25, 11.42, 11.06, 10.90, 10.93, 10.97, 11.00, 10.67,
+            10.57, 10.50, 10.83, 10.85, 10.92, 11.10, 11.11, 11.10, 11.25,
+            11.53, 11.45, 11.41, 11.31, 11.31, 11.24, 11.48, 11.47, 11.49,
+            11.47, 11.27, 11.10, 11.39, 11.67, 11.73, 11.77, 11.86, 12.40,
+            12.79, 12.76, 12.87, 12.95
+        ]),
+        'volume': np.asarray([
+            45709900, 79725200, 67877500, 59840700, 53981500, 121750600,
+            63806000, 48687700, 46366700, 44398400, 47102700, 70894200,
+            43705700, 49379700, 45768400, 54021600, 75470700, 142155300,
+            57752600, 46412100, 71669000, 48347600, 78851200, 46363300,
+            39413500, 35352500, 52290500, 52505500, 34474400, 39627900,
+            38174800, 49164400, 30778000, 38409800, 43326000, 36747600,
+            31399300, 38703400, 30789000, 62093700, 68262000, 49063500,
+            28433700, 57374500, 28440900, 37099100, 36159300, 30275700,
+            42783600, 47578500, 55286600, 77119600, 52445700, 40214400,
+            27521400, 50117100, 44755000, 26692200, 35070700, 41051700,
+            51039700, 36381000, 43966900, 97034200, 51505000, 37939500,
+            42515300, 77370300, 34724400, 26988800, 39675000, 31903500,
+            35981200, 32314000, 48169200, 52631000, 31269200, 38615200,
+            45185400, 40889300, 83070300, 46156300, 43959200, 48572900,
+            40238400, 53268400, 33235200, 46174500, 54501200, 42526100,
+            36561300, 50225200, 41886500, 44321300, 49648900, 50572000,
+            38134900, 44295700, 75647800, 45334100, 30430800, 43760600,
+            44592100, 54297000, 68237000, 57305600, 38326200, 50458000,
+            33846100, 30811600, 35811400, 35130800, 53471900, 37531800,
+            39442000, 27361000, 37155900, 40810100, 40062800, 56427300,
+            44297600, 31871900, 33278900, 38648400, 138138600, 63388600,
+            49629300, 31783900, 30355400, 37441600, 33516600, 32028700,
+            55111000, 30248300, 28838200, 29510000, 31010000, 33615000,
+            27968300, 33773800, 53519200, 44338200, 51798900, 67986800,
+            40958300, 41360900, 65973000, 45326500, 38631400, 23819100,
+            43574500, 22630300, 30909800, 19618800, 21122000, 21129500,
+            21308300, 34323700, 34533900, 38923800, 26281100, 26965500,
+            23537700, 19574600, 22754200, 23084400, 26115700, 16459400,
+            28029200, 37965000, 40608800, 67996400, 60617000, 43381300,
+            28165300, 28046500, 50920200, 55934300, 31922200, 34937000,
+            42403000, 28755100, 35459800, 28557900, 36866300, 44362600,
+            25740900, 44586300, 33445600, 63630000, 51023800, 46855500,
+            40693900, 25473900, 38235700, 33951600, 39328700, 24108500,
+            26466500, 32788400, 29346300, 44041700, 40493000, 39149700,
+            32476500, 49339800, 59290900, 43485500, 137960900, 88770100,
+            53399000, 37995000, 51232200, 56674900, 45948800, 40703600,
+            25723100, 33342900, 45664700, 48879800, 45346200, 39359100,
+            34739800, 21181700, 16032200, 26831700, 37610000, 38496900,
+            57289300, 41329600, 47746300, 37760200, 33152400, 31065800,
+            38404500, 26025200, 36326900, 31099900, 35443200, 36933500,
+            46983300, 61810400, 54884700, 47750100, 94489300, 91734900,
+            140331900, 108315100, 95668600, 106908900
+        ])
+    }
+
+
+@pytest.fixture(scope='session')
+def series():
+    return np.array([
+        91.50, 94.81, 94.38, 95.09, 93.78, 94.62, 92.53, 92.75, 90.31, 92.47,
+        96.12, 97.25, 98.50, 89.88, 91.00, 92.81, 89.16, 89.34, 91.62, 89.88,
+        88.38, 87.62, 84.78, 83.00, 83.50, 81.38, 84.44, 89.25, 86.38, 86.25,
+        85.25, 87.12, 85.81, 88.97, 88.47, 86.88, 86.81, 84.88, 84.19, 83.88,
+        83.38, 85.50, 89.19, 89.44, 91.09, 90.75, 91.44, 89.00, 91.00, 90.50,
+        89.03, 88.81, 84.28, 83.50, 82.69, 84.75, 85.66, 86.19, 88.94, 89.28,
+        88.62, 88.50, 91.97, 91.50, 93.25, 93.50, 93.16, 91.72, 90.00, 89.69,
+        88.88, 85.19, 83.38, 84.88, 85.94, 97.25, 99.88, 104.94, 106.00, 102.50,
+        102.41, 104.59, 106.12, 106.00, 106.06, 104.62, 108.62, 109.31, 110.50,
+        112.75, 123.00, 119.62, 118.75, 119.25, 117.94, 116.44, 115.19, 111.88,
+        110.59, 118.12, 116.00, 116.00, 112.00, 113.75, 112.94, 116.00, 120.50,
+        116.62, 117.00, 115.25, 114.31, 115.50, 115.87, 120.69, 120.19, 120.75,
+        124.75, 123.37, 122.94, 122.56, 123.12, 122.56, 124.62, 129.25, 131.00,
+        132.25, 131.00, 132.81, 134.00, 137.38, 137.81, 137.88, 137.25, 136.31,
+        136.25, 134.63, 128.25, 129.00, 123.87, 124.81, 123.00, 126.25, 128.38,
+        125.37, 125.69, 122.25, 119.37, 118.50, 123.19, 123.50, 122.19, 119.31,
+        123.31, 121.12, 123.37, 127.37, 128.50, 123.87, 122.94, 121.75, 124.44,
+        122.00, 122.37, 122.94, 124.00, 123.19, 124.56, 127.25, 125.87, 128.86,
+        132.00, 130.75, 134.75, 135.00, 132.38, 133.31, 131.94, 130.00, 125.37,
+        130.13, 127.12, 125.19, 122.00, 125.00, 123.00, 123.50, 120.06, 121.00,
+        117.75, 119.87, 122.00, 119.19, 116.37, 113.50, 114.25, 110.00, 105.06,
+        107.00, 107.87, 107.00, 107.12, 107.00, 91.00, 93.94, 93.87, 95.50,
+        93.00, 94.94, 98.25, 96.75, 94.81, 94.37, 91.56, 90.25, 93.94, 93.62,
+        97.00, 95.00, 95.87, 94.06, 94.62, 93.75, 98.00, 103.94, 107.87, 106.06,
+        104.50, 105.00, 104.19, 103.06, 103.42, 105.27, 111.87, 116.00, 116.62,
+        118.28, 113.37, 109.00, 109.70, 109.25, 107.00, 109.19, 110.00, 109.20,
+        110.12, 108.00, 108.62, 109.75, 109.81, 109.00, 108.75, 107.87
+    ])
\ No newline at end of file
diff --git a/talib/test_abstract.py b/tests/test_abstract.py
similarity index 52%
rename from talib/test_abstract.py
rename to tests/test_abstract.py
index 7e381f2f1..c7440e58c 100644
--- a/talib/test_abstract.py
+++ b/tests/test_abstract.py
@@ -1,10 +1,11 @@
+import copy
+import re
+import threading
+import time
+
 import numpy as np
-from nose.tools import (
-    assert_equals,
-    assert_true,
-    assert_false,
-    assert_raises,
-    )
+import pytest
+from numpy.testing import assert_array_equal, assert_raises
 
 try:
     from collections import OrderedDict
@@ -12,109 +13,120 @@
     from ordereddict import OrderedDict
 
 import talib
-from talib import func
-from talib import abstract
-from talib.test_data import ford_2012, assert_np_arrays_equal, assert_np_arrays_not_equal
+from talib import abstract, func
+
+
+def assert_array_not_equal(x, y):
+    assert_raises(AssertionError, assert_array_equal, x, y)
+
+
+def test_pararmeters():
+    parameters = abstract.MACD.parameters
+    assert all(type(v) == int for k, v in parameters.items())
 
 
-def test_pandas():
+def test_pandas(ford_2012):
     import pandas
     input_df = pandas.DataFrame(ford_2012)
     input_dict = dict((k, pandas.Series(v)) for k, v in ford_2012.items())
 
     expected_k, expected_d = func.STOCH(ford_2012['high'], ford_2012['low'], ford_2012['close']) # 5, 3, 0, 3, 0
     output = abstract.Function('stoch', input_df).outputs
-    assert_true(isinstance(output, pandas.DataFrame))
-    assert_np_arrays_equal(expected_k, output['slowk'])
-    assert_np_arrays_equal(expected_d, output['slowd'])
+    assert isinstance(output, pandas.DataFrame)
+    assert_array_equal(expected_k, output['slowk'])
+    assert_array_equal(expected_d, output['slowd'])
     output = abstract.Function('stoch', input_dict).outputs
-    assert_true(isinstance(output, list))
-    assert_np_arrays_equal(expected_k, output[0])
-    assert_np_arrays_equal(expected_d, output[1])
+    assert isinstance(output, list)
+    assert_array_equal(expected_k, output[0])
+    assert_array_equal(expected_d, output[1])
 
     expected = func.SMA(ford_2012['close'], 10)
     output = abstract.Function('sma', input_df, 10).outputs
-    assert_true(isinstance(output, pandas.Series))
-    assert_np_arrays_equal(expected, output)
+    assert isinstance(output, pandas.Series)
+    assert_array_equal(expected, output)
     output = abstract.Function('sma', input_dict, 10).outputs
-    assert_true(isinstance(output, np.ndarray))
-    assert_np_arrays_equal(expected, output)
+    assert isinstance(output, np.ndarray)
+    assert_array_equal(expected, output)
 
 
-def test_pandas_series():
+def test_pandas_series(ford_2012):
     import pandas
     input_df = pandas.DataFrame(ford_2012)
     output = talib.SMA(input_df['close'], 10)
     expected = pandas.Series(func.SMA(ford_2012['close'], 10),
                              index=input_df.index)
-    pandas.util.testing.assert_series_equal(output, expected)
+    pandas.testing.assert_series_equal(output, expected)
 
     # Test kwargs
     output = talib.SMA(real=input_df['close'], timeperiod=10)
-    pandas.util.testing.assert_series_equal(output, expected)
+    pandas.testing.assert_series_equal(output, expected)
 
     # Test talib.func API
     output = func.SMA(input_df['close'], timeperiod=10)
-    pandas.util.testing.assert_series_equal(output, expected)
+    pandas.testing.assert_series_equal(output, expected)
 
     # Test multiple outputs such as from BBANDS
     _, output, _ = talib.BBANDS(input_df['close'], 10)
     expected = pandas.Series(func.BBANDS(ford_2012['close'], 10)[1],
                              index=input_df.index)
-    pandas.util.testing.assert_series_equal(output, expected)
+    pandas.testing.assert_series_equal(output, expected)
 
 
-def test_SMA():
+def test_SMA(ford_2012):
     expected = func.SMA(ford_2012['close'], 10)
-    assert_np_arrays_equal(expected, abstract.Function('sma', ford_2012, 10).outputs)
-    assert_np_arrays_equal(expected, abstract.Function('sma')(ford_2012, 10, price='close'))
-    assert_np_arrays_equal(expected, abstract.Function('sma')(ford_2012, timeperiod=10))
+    assert_array_equal(expected, abstract.Function('sma', ford_2012, 10).outputs)
+    assert_array_equal(expected, abstract.Function('sma')(ford_2012, 10, price='close'))
+    assert_array_equal(expected, abstract.Function('sma')(ford_2012, timeperiod=10))
     expected = func.SMA(ford_2012['open'], 10)
-    assert_np_arrays_equal(expected, abstract.Function('sma', ford_2012, 10, price='open').outputs)
-    assert_np_arrays_equal(expected, abstract.Function('sma', price='low')(ford_2012, 10, price='open'))
-    assert_np_arrays_not_equal(expected, abstract.Function('sma', ford_2012, 10, price='open')(timeperiod=20))
-    assert_np_arrays_not_equal(expected, abstract.Function('sma', ford_2012)(10, price='close'))
-    assert_np_arrays_not_equal(expected, abstract.Function('sma', 10)(ford_2012, price='high'))
-    assert_np_arrays_not_equal(expected, abstract.Function('sma', price='low')(ford_2012, 10))
+    assert_array_equal(expected, abstract.Function('sma', ford_2012, 10, price='open').outputs)
+    assert_array_equal(expected, abstract.Function('sma', price='low')(ford_2012, 10, price='open'))
+    assert_array_not_equal(expected, abstract.Function('sma', ford_2012, 10, price='open')(timeperiod=20))
+    assert_array_not_equal(expected, abstract.Function('sma', ford_2012)(10, price='close'))
+    assert_array_not_equal(expected, abstract.Function('sma', 10)(ford_2012, price='high'))
+    assert_array_not_equal(expected, abstract.Function('sma', price='low')(ford_2012, 10))
     input_arrays = {'foobarbaz': ford_2012['open']}
-    assert_np_arrays_equal(expected, abstract.SMA(input_arrays, 10, price='foobarbaz'))
+    assert_array_equal(expected, abstract.SMA(input_arrays, 10, price='foobarbaz'))
 
 
-def test_STOCH():
+def test_STOCH(ford_2012):
     # check defaults match
     expected_k, expected_d = func.STOCH(ford_2012['high'], ford_2012['low'], ford_2012['close']) # 5, 3, 0, 3, 0
     got_k, got_d = abstract.Function('stoch', ford_2012).outputs
-    assert_np_arrays_equal(expected_k, got_k)
-    assert_np_arrays_equal(expected_d, got_d)
+    assert_array_equal(expected_k, got_k)
+    assert_array_equal(expected_d, got_d)
 
     expected_k, expected_d = func.STOCH(ford_2012['high'], ford_2012['low'], ford_2012['close'])
     got_k, got_d = abstract.Function('stoch', ford_2012)(5, 3, 0, 3, 0)
-    assert_np_arrays_equal(expected_k, got_k)
-    assert_np_arrays_equal(expected_d, got_d)
+    assert_array_equal(expected_k, got_k)
+    assert_array_equal(expected_d, got_d)
 
     expected_k, expected_d = func.STOCH(ford_2012['high'], ford_2012['low'], ford_2012['close'], 15)
     got_k, got_d = abstract.Function('stoch', ford_2012)(15, 5, 0, 5, 0)
-    assert_np_arrays_not_equal(expected_k, got_k)
-    assert_np_arrays_not_equal(expected_d, got_d)
+    assert_array_not_equal(expected_k, got_k)
+    assert_array_not_equal(expected_d, got_d)
 
     expected_k, expected_d = func.STOCH(ford_2012['high'], ford_2012['low'], ford_2012['close'], 15, 5, 1, 5, 1)
     got_k, got_d = abstract.Function('stoch', ford_2012)(15, 5, 1, 5, 1)
-    assert_np_arrays_equal(expected_k, got_k)
-    assert_np_arrays_equal(expected_d, got_d)
+    assert_array_equal(expected_k, got_k)
+    assert_array_equal(expected_d, got_d)
 
-def test_doji_candle():
+
+def test_doji_candle(ford_2012):
     expected = func.CDLDOJI(ford_2012['open'], ford_2012['high'], ford_2012['low'], ford_2012['close'])
     got = abstract.Function('CDLDOJI').run(ford_2012)
-    assert_np_arrays_equal(got, expected)
+    assert_array_equal(got, expected)
+
 
-def test_MAVP():
+def test_MAVP(ford_2012):
     mavp = abstract.MAVP
-    assert_raises(Exception, mavp.set_input_arrays, ford_2012)
+    with pytest.raises(Exception):
+        mavp.set_input_arrays(ford_2012)
     input_d = {}
     input_d['close'] = ford_2012['close']
     input_d['periods'] = np.arange(30)
-    assert_true(mavp.set_input_arrays(input_d))
-    assert_equals(mavp.input_arrays, input_d)
+    assert mavp.set_input_arrays(input_d)
+    assert mavp.input_arrays == input_d
+
 
 def test_info():
     stochrsi = abstract.Function('STOCHRSI')
@@ -138,7 +150,7 @@ def test_info():
             ('fastd_matype', 1),
             ]),
         }
-    assert_equals(expected, stochrsi.info)
+    assert expected == stochrsi.info
 
     expected = {
         'display_name': 'Bollinger Bands',
@@ -159,11 +171,12 @@ def test_info():
             ('matype', 0),
             ]),
         }
-    assert_equals(expected, abstract.Function('BBANDS').info)
+    assert expected == abstract.Function('BBANDS').info
+
 
 def test_input_names():
     expected = OrderedDict([('price', 'close')])
-    assert_equals(expected, abstract.Function('MAMA').input_names)
+    assert expected == abstract.Function('MAMA').input_names
 
     # test setting input_names
     obv = abstract.Function('OBV')
@@ -172,51 +185,49 @@ def test_input_names():
         ('prices', ['volume']),
         ])
     obv.input_names = expected
-    assert_equals(obv.input_names, expected)
+    assert obv.input_names == expected
 
     obv.input_names = {
         'price': 'open',
         'prices': ['volume'],
         }
-    assert_equals(obv.input_names, expected)
+    assert obv.input_names == expected
 
-def test_input_arrays():
+
+def test_input_arrays(ford_2012):
     mama = abstract.Function('MAMA')
+
     # test default setting
-    expected = {
-        'open': None,
-        'high': None,
-        'low': None,
-        'close': None,
-        'volume': None,
-        }
-    assert_equals(expected, mama.get_input_arrays())
+    assert mama.get_input_arrays() == {}
+
     # test setting/getting input_arrays
-    assert_true(mama.set_input_arrays(ford_2012))
-    assert_equals(mama.get_input_arrays(), ford_2012)
-    assert_raises(Exception,
-                  mama.set_input_arrays, {'hello': 'fail', 'world': 'bye'})
+    assert mama.set_input_arrays(ford_2012)
+    assert mama.get_input_arrays() == ford_2012
+    with pytest.raises(Exception):
+        mama.set_input_arrays({'hello': 'fail', 'world': 'bye'})
 
     # test only required keys are needed
     willr = abstract.Function('WILLR')
     reqd = willr.input_names['prices']
     input_d = dict([(key, ford_2012[key]) for key in reqd])
-    assert_true(willr.set_input_arrays(input_d))
-    assert_equals(willr.input_arrays, input_d)
+    assert willr.set_input_arrays(input_d)
+    assert willr.input_arrays == input_d
 
     # test extraneous keys are ignored
     input_d['extra_stuffs'] = 'you should never see me'
     input_d['date'] = np.random.rand(100)
-    assert_true(willr.set_input_arrays(input_d))
+    assert willr.set_input_arrays(input_d)
 
     # test missing keys get detected
     input_d['open'] = ford_2012['open']
     input_d.pop('close')
-    assert_raises(Exception, willr.set_input_arrays, input_d)
+    with pytest.raises(Exception):
+        willr.set_input_arrays(input_d)
 
     # test changing input_names on the Function
     willr.input_names = {'prices': ['high', 'low', 'open']}
-    assert_true(willr.set_input_arrays(input_d))
+    assert willr.set_input_arrays(input_d)
+
 
 def test_parameters():
     stoch = abstract.Function('STOCH')
@@ -227,20 +238,20 @@ def test_parameters():
         ('slowd_period', 3),
         ('slowd_matype', 0),
         ])
-    assert_equals(expected, stoch.parameters)
+    assert expected == stoch.parameters
 
     stoch.parameters = {'fastk_period': 10}
     expected['fastk_period'] = 10
-    assert_equals(expected, stoch.parameters)
+    assert expected == stoch.parameters
 
     stoch.parameters = {'slowk_period': 8, 'slowd_period': 5}
     expected['slowk_period'] = 8
     expected['slowd_period'] = 5
-    assert_equals(expected, stoch.parameters)
+    assert expected == stoch.parameters
 
     stoch.parameters = {'slowd_matype': talib.MA_Type.T3}
     expected['slowd_matype'] = 8
-    assert_equals(expected, stoch.parameters)
+    assert expected == stoch.parameters
 
     stoch.parameters = {
         'slowk_matype': talib.MA_Type.WMA,
@@ -248,68 +259,116 @@ def test_parameters():
         }
     expected['slowk_matype'] = 2
     expected['slowd_matype'] = 1
-    assert_equals(expected, stoch.parameters)
+    assert expected == stoch.parameters
+
 
 def test_lookback():
-    assert_equals(abstract.Function('SMA', 10).lookback, 9)
+    assert abstract.Function('SMA', 10).lookback == 9
 
     stochrsi = abstract.Function('stochrsi', 20, 5, 3)
-    assert_equals(stochrsi.lookback, 26)
+    assert stochrsi.lookback == 26
 
-def test_call_supports_same_signature_as_func_module():
+
+def test_call_supports_same_signature_as_func_module(ford_2012):
     adx = abstract.Function('ADX')
 
     expected = func.ADX(ford_2012['open'], ford_2012['high'], ford_2012['low'])
     output = adx(ford_2012['open'], ford_2012['high'], ford_2012['low'])
-    assert_np_arrays_equal(expected, output)
+    assert_array_equal(expected, output)
+
+    expected_error = re.escape('Too many price arguments: expected 3 (high, low, close)')
 
-    with assert_raises(TypeError) as e:
+    with pytest.raises(TypeError, match=expected_error):
         adx(ford_2012['open'], ford_2012['high'], ford_2012['low'], ford_2012['close'])
-        assert 'Too many price arguments: expected 3 (open, high, low)' in str(
-            e.exception.message)
 
-    with assert_raises(TypeError) as e:
+    expected_error = re.escape('Not enough price arguments: expected 3 (high, low, close)')
+
+    with pytest.raises(TypeError, match=expected_error):
         adx(ford_2012['open'], ford_2012['high'])
-        assert 'Not enough price arguments: expected 3 (open, high, low)' in str(
-            e.exception.message)
 
-def test_parameter_type_checking():
+
+def test_parameter_type_checking(ford_2012):
     sma = abstract.Function('SMA', timeperiod=10)
 
-    expected_error = 'Invalid parameter value for timeperiod (expected int, got float)'
+    expected_error = re.escape('Invalid parameter value for timeperiod (expected int, got float)')
 
-    with assert_raises(TypeError) as e:
+    with pytest.raises(TypeError, match=expected_error):
         sma(ford_2012['close'], 35.5)
-        assert expected_error in str(e.exception.message)
 
-    with assert_raises(TypeError) as e:
+    with pytest.raises(TypeError, match=expected_error):
         abstract.Function('SMA', timeperiod=35.5)
-        assert expected_error in str(e.exception.message)
 
-    with assert_raises(TypeError) as e:
+    with pytest.raises(TypeError, match=expected_error):
         sma.parameters = {'timeperiod': 35.5}
-        assert expected_error in str(e.exception.message)
 
-    with assert_raises(TypeError) as e:
+    with pytest.raises(TypeError, match=expected_error):
         sma.set_parameters(timeperiod=35.5)
-        assert expected_error in str(e.exception.message)
 
-def test_call_doesnt_cache_parameters():
+
+def test_call_doesnt_cache_parameters(ford_2012):
     sma = abstract.Function('SMA', timeperiod=10)
 
+    expected = func.SMA(ford_2012['open'], 20)
+    output = sma(ford_2012, timeperiod=20, price='open')
+    assert_array_equal(expected, output)
+
     expected = func.SMA(ford_2012['close'], 20)
     output = sma(ford_2012, timeperiod=20)
-    assert_np_arrays_equal(expected, output)
+    assert_array_equal(expected, output)
 
     expected = func.SMA(ford_2012['close'], 10)
     output = sma(ford_2012)
-    assert_np_arrays_equal(expected, output)
+    assert_array_equal(expected, output)
+
 
 def test_call_without_arguments():
-    with assert_raises(TypeError) as e:
+    with pytest.raises(TypeError, match='Not enough price arguments'):
         abstract.Function('SMA')()
-        assert 'Not enough price arguments' in str(e.exception.message)
 
-    with assert_raises(TypeError) as e:
+    with pytest.raises(TypeError, match='Not enough price arguments'):
         abstract.Function('SMA')(10)
-        assert 'Not enough price arguments' in str(e.exception.message)
+
+
+def test_threading():
+    import pandas as pd
+    TEST_LEN_SHORT = 999
+    TEST_LEN_LONG = 4005
+    LOOPS = 1000
+    THREADS = 4
+
+    data_short = np.random.rand(TEST_LEN_SHORT, 5)
+    data_long = np.random.rand(TEST_LEN_LONG, 5)
+
+    df_short = pd.DataFrame(data_short, columns=['open', 'high', 'low', 'close', 'volume'])
+    df_long = pd.DataFrame(data_long, columns=['open', 'high', 'low', 'close', 'volume'])
+
+    total = 0
+
+    def loop(i):
+        nonlocal total
+        if i % 2 == 0:
+            df = copy.deepcopy(df_short)
+        else:
+            df = copy.deepcopy(df_long)
+
+        for _ in range(LOOPS):
+            total += 1
+            df['RSI'] = abstract.RSI(df)
+
+    t0 = time.time()
+
+    threads = []
+    for i in range(THREADS):
+        t = threading.Thread(target=lambda: loop(i))
+        threads.append(t)
+        t.start()
+
+    for t in threads:
+        t.join()
+
+    t1 = time.time()
+    print('test_len: %d, loops: %d' % (TEST_LEN_LONG, LOOPS))
+    print('%.6f' % (t1 - t0))
+    print('%.6f' % ((t1 - t0) / LOOPS))
+
+    assert total == THREADS * LOOPS
diff --git a/tests/test_func.py b/tests/test_func.py
new file mode 100644
index 000000000..cb1e36ffa
--- /dev/null
+++ b/tests/test_func.py
@@ -0,0 +1,197 @@
+import numpy as np
+from numpy.testing import assert_array_equal, assert_array_almost_equal
+import pytest
+
+import talib
+from talib import func
+
+
+def test_talib_version():
+    assert talib.__ta_version__[:5] == b'0.6.4'
+
+
+def test_num_functions():
+    assert len(talib.get_functions()) == 161
+
+
+def test_input_wrong_type():
+    a1 = np.arange(10, dtype=int)
+    with pytest.raises(Exception):
+        func.MOM(a1)
+
+
+def test_input_lengths():
+    a1 = np.arange(10, dtype=float)
+    a2 = np.arange(11, dtype=float)
+    with pytest.raises(Exception):
+        func.BOP(a2, a1, a1, a1)
+    with pytest.raises(Exception):
+        func.BOP(a1, a2, a1, a1)
+    with pytest.raises(Exception):
+        func.BOP(a1, a1, a2, a1)
+    with pytest.raises(Exception):
+        func.BOP(a1, a1, a1, a2)
+
+
+def test_input_allnans():
+    a = np.arange(20, dtype=float)
+    a[:] = np.nan
+    r = func.RSI(a)
+    assert np.all(np.isnan(r))
+
+
+def test_input_nans():
+    a1 = np.arange(10, dtype=float)
+    a2 = np.arange(10, dtype=float)
+    a2[0] = np.nan
+    a2[1] = np.nan
+    r1, r2 = func.AROON(a1, a2, 2)
+    assert_array_equal(r1, [np.nan, np.nan, np.nan, np.nan, 0, 0, 0, 0, 0, 0])
+    assert_array_equal(r2, [np.nan, np.nan, np.nan, np.nan, 100, 100, 100, 100, 100, 100])
+    r1, r2 = func.AROON(a2, a1, 2)
+    assert_array_equal(r1, [np.nan, np.nan, np.nan, np.nan, 0, 0, 0, 0, 0, 0])
+    assert_array_equal(r2, [np.nan, np.nan, np.nan, np.nan, 100, 100, 100, 100, 100, 100])
+
+
+def test_unstable_period():
+    a = np.arange(10, dtype=float)
+    r = func.EMA(a, 3)
+    assert_array_equal(r, [np.nan, np.nan, 1, 2, 3, 4, 5, 6, 7, 8])
+    talib.set_unstable_period('EMA', 5)
+    r = func.EMA(a, 3)
+    assert_array_equal(r, [np.nan, np.nan, np.nan, np.nan, np.nan, np.nan, np.nan, 6, 7, 8])
+    talib.set_unstable_period('EMA', 0)
+
+
+def test_compatibility():
+    a = np.arange(10, dtype=float)
+    talib.set_compatibility(0)
+    r = func.EMA(a, 3)
+    assert_array_equal(r, [np.nan, np.nan, 1, 2, 3, 4, 5, 6, 7, 8])
+    talib.set_compatibility(1)
+    r = func.EMA(a, 3)
+    assert_array_equal(r, [np.nan, np.nan,1.25,2.125,3.0625,4.03125,5.015625,6.0078125,7.00390625,8.001953125])
+    talib.set_compatibility(0)
+
+
+def test_MIN(series):
+    result = func.MIN(series, timeperiod=4)
+    i = np.where(~np.isnan(result))[0][0]
+    assert len(series) == len(result)
+    assert result[i + 1] == 93.780
+    assert result[i + 2] == 93.780
+    assert result[i + 3] == 92.530
+    assert result[i + 4] == 92.530
+    values = np.array([np.nan, 5., 4., 3., 5., 7.])
+    result = func.MIN(values, timeperiod=2)
+    assert_array_equal(result, [np.nan, np.nan, 4, 3, 3, 5])
+
+
+def test_MAX(series):
+    result = func.MAX(series, timeperiod=4)
+    i = np.where(~np.isnan(result))[0][0]
+    assert len(series) == len(result)
+    assert result[i + 2] == 95.090
+    assert result[i + 3] == 95.090
+    assert result[i + 4] == 94.620
+    assert result[i + 5] == 94.620
+
+
+def test_MOM():
+    values = np.array([90.0,88.0,89.0])
+    result = func.MOM(values, timeperiod=1)
+    assert_array_equal(result, [np.nan, -2, 1])
+    result = func.MOM(values, timeperiod=2)
+    assert_array_equal(result, [np.nan, np.nan, -1])
+    result = func.MOM(values, timeperiod=3)
+    assert_array_equal(result, [np.nan, np.nan, np.nan])
+    result = func.MOM(values, timeperiod=4)
+    assert_array_equal(result, [np.nan, np.nan, np.nan])
+
+
+def test_BBANDS(series):
+    upper, middle, lower = func.BBANDS(
+        series,
+        timeperiod=20,
+        nbdevup=2.0,
+        nbdevdn=2.0,
+        matype=talib.MA_Type.EMA
+    )
+    i = np.where(~np.isnan(upper))[0][0]
+    assert len(upper) == len(middle) == len(lower) == len(series)
+    # assert abs(upper[i + 0] - 98.0734) < 1e-3
+    assert abs(middle[i + 0] - 92.8910) < 1e-3
+    assert abs(lower[i + 0] - 87.7086) < 1e-3
+    # assert abs(upper[i + 13] - 93.674) < 1e-3
+    assert abs(middle[i + 13] - 87.679) < 1e-3
+    assert abs(lower[i + 13] - 81.685) < 1e-3
+
+
+def test_DEMA(series):
+    result = func.DEMA(series)
+    i = np.where(~np.isnan(result))[0][0]
+    assert len(series) == len(result)
+    assert abs(result[i + 1] - 86.765) < 1e-3
+    assert abs(result[i + 2] - 86.942) < 1e-3
+    assert abs(result[i + 3] - 87.089) < 1e-3
+    assert abs(result[i + 4] - 87.656) < 1e-3
+
+
+def test_EMAEMA(series):
+    result = func.EMA(series, timeperiod=2)
+    result = func.EMA(result, timeperiod=2)
+    i = np.where(~np.isnan(result))[0][0]
+    assert len(series) == len(result)
+    assert i == 2
+
+
+def test_CDL3BLACKCROWS():
+    o = np.array([39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 40.32, 40.51, 38.09, 35.00, 27.66, 30.80])
+    h = np.array([40.84, 40.84, 40.84, 40.84, 40.84, 40.84, 40.84, 40.84, 40.84, 40.84, 40.84, 40.84, 40.84, 40.84, 41.69, 40.84, 38.12, 35.50, 31.74, 32.51])
+    l = np.array([35.80, 35.80, 35.80, 35.80, 35.80, 35.80, 35.80, 35.80, 35.80, 35.80, 35.80, 35.80, 35.80, 35.80, 39.26, 36.73, 33.37, 30.03, 27.03, 28.31])
+    c = np.array([40.29, 40.29, 40.29, 40.29, 40.29, 40.29, 40.29, 40.29, 40.29, 40.29, 40.29, 40.29, 40.29, 40.29, 40.46, 37.08, 33.37, 30.03, 31.46, 28.31])
+
+    result = func.CDL3BLACKCROWS(o, h, l, c)
+    assert_array_equal(result, [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -100, 0, 0])
+
+
+def test_RSI():
+    a = np.array([0.00000024, 0.00000024, 0.00000024,
+      0.00000024, 0.00000024, 0.00000023,
+      0.00000024, 0.00000024, 0.00000024,
+      0.00000024, 0.00000023, 0.00000024,
+      0.00000023, 0.00000024, 0.00000023,
+      0.00000024, 0.00000024, 0.00000023,
+      0.00000023, 0.00000023], dtype='float64')
+    result = func.RSI(a, 10)
+    assert_array_almost_equal(result, [np.nan,np.nan,np.nan,np.nan,np.nan,np.nan,np.nan,np.nan,np.nan,np.nan,33.333333333333329,51.351351351351347,39.491916859122398,51.84807024709005,42.25953803191981,52.101824405061215,52.101824405061215,43.043664867691085,43.043664867691085,43.043664867691085])
+    result = func.RSI(a * 100000, 10)
+    assert_array_almost_equal(result, [np.nan,np.nan,np.nan,np.nan,np.nan,np.nan,np.nan,np.nan,np.nan,np.nan,33.333333333333329,51.351351351351347,39.491916859122398,51.84807024709005,42.25953803191981,52.101824405061215,52.101824405061215,43.043664867691085,43.043664867691085,43.043664867691085])
+
+
+def test_MAVP():
+    a = np.array([1,5,3,4,7,3,8,1,4,6], dtype=float)
+    b = np.array([2,4,2,4,2,4,2,4,2,4], dtype=float)
+    result = func.MAVP(a, b, minperiod=2, maxperiod=4)
+    assert_array_equal(result, [np.nan,np.nan,np.nan,3.25,5.5,4.25,5.5,4.75,2.5,4.75])
+    sma2 = func.SMA(a, 2)
+    assert_array_equal(result[4::2], sma2[4::2])
+    sma4 = func.SMA(a, 4)
+    assert_array_equal(result[3::2], sma4[3::2])
+    result = func.MAVP(a, b, minperiod=2, maxperiod=3)
+    assert_array_equal(result, [np.nan,np.nan,4,4,5.5,4.666666666666667,5.5,4,2.5,3.6666666666666665])
+    sma3 = func.SMA(a, 3)
+    assert_array_equal(result[2::2], sma2[2::2])
+    assert_array_equal(result[3::2], sma3[3::2])
+
+
+def test_MAXINDEX():
+    import talib as func
+    import numpy as np
+    a = np.array([1., 2, 3, 4, 5, 6, 7, 8, 7, 7, 3, 4, 5, 6, 7, 8, 9, 2, 3, 4, 5, 15])
+    b = func.MA(a, 10)
+    c = func.MAXINDEX(b, 10)
+    assert_array_equal(c, [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,16,16,16,21])
+    d = np.array([1., 2, 3])
+    e = func.MAXINDEX(d, 10)
+    assert_array_equal(e, [0,0,0])
diff --git a/tests/test_pandas.py b/tests/test_pandas.py
new file mode 100644
index 000000000..78f1a1236
--- /dev/null
+++ b/tests/test_pandas.py
@@ -0,0 +1,51 @@
+import numpy as np
+from numpy.testing import assert_array_equal
+import pandas as pd
+
+import talib
+
+
+def test_MOM():
+    values = pd.Series([90.0,88.0,89.0], index=[10, 20, 30])
+    result = talib.MOM(values, timeperiod=1)
+    assert isinstance(result, pd.Series)
+    assert_array_equal(result.values, [np.nan, -2, 1])
+    assert_array_equal(result.index, [10, 20, 30])
+    result = talib.MOM(values, timeperiod=2)
+    assert isinstance(result, pd.Series)
+    assert_array_equal(result.values, [np.nan, np.nan, -1])
+    assert_array_equal(result.index, [10, 20, 30])
+    result = talib.MOM(values, timeperiod=3)
+    assert isinstance(result, pd.Series)
+    assert_array_equal(result.values, [np.nan, np.nan, np.nan])
+    assert_array_equal(result.index, [10, 20, 30])
+    result = talib.MOM(values, timeperiod=4)
+    assert isinstance(result, pd.Series)
+    assert_array_equal(result.values, [np.nan, np.nan, np.nan])
+    assert_array_equal(result.index, [10, 20, 30])
+
+
+def test_MAVP():
+    a = pd.Series([1,5,3,4,7,3,8,1,4,6], index=range(10, 20), dtype=float)
+    b = pd.Series([2,4,2,4,2,4,2,4,2,4], index=range(20, 30), dtype=float)
+    result = talib.MAVP(a, b, minperiod=2, maxperiod=4)
+    assert isinstance(result, pd.Series)
+    assert_array_equal(result.values, [np.nan,np.nan,np.nan,3.25,5.5,4.25,5.5,4.75,2.5,4.75])
+    assert_array_equal(result.index, range(10, 20))
+    sma2 = talib.SMA(a, 2)
+    assert isinstance(sma2, pd.Series)
+    assert_array_equal(sma2.index, range(10, 20))
+    assert_array_equal(result.values[4::2], sma2.values[4::2])
+    sma4 = talib.SMA(a, 4)
+    assert isinstance(sma4, pd.Series)
+    assert_array_equal(sma4.index, range(10, 20))
+    assert_array_equal(result.values[3::2], sma4.values[3::2])
+    result = talib.MAVP(a, b, minperiod=2, maxperiod=3)
+    assert isinstance(result, pd.Series)
+    assert_array_equal(result.values, [np.nan,np.nan,4,4,5.5,4.666666666666667,5.5,4,2.5,3.6666666666666665])
+    assert_array_equal(result.index, range(10, 20))
+    sma3 = talib.SMA(a, 3)
+    assert isinstance(sma3, pd.Series)
+    assert_array_equal(sma3.index, range(10, 20))
+    assert_array_equal(result.values[2::2], sma2.values[2::2])
+    assert_array_equal(result.values[3::2], sma3.values[3::2])
diff --git a/tests/test_polars.py b/tests/test_polars.py
new file mode 100644
index 000000000..f83e594d9
--- /dev/null
+++ b/tests/test_polars.py
@@ -0,0 +1,88 @@
+import numpy as np
+from numpy.testing import assert_array_equal
+import polars as pl
+
+import talib
+from talib import abstract
+
+def test_MOM():
+    values = pl.Series([90.0,88.0,89.0])
+    result = talib.MOM(values, timeperiod=1)
+    assert isinstance(result, pl.Series)
+    assert_array_equal(result.to_numpy(), [np.nan, -2, 1])
+    result = talib.MOM(values, timeperiod=2)
+    assert isinstance(result, pl.Series)
+    assert_array_equal(result.to_numpy(), [np.nan, np.nan, -1])
+    result = talib.MOM(values, timeperiod=3)
+    assert isinstance(result, pl.Series)
+    assert_array_equal(result.to_numpy(), [np.nan, np.nan, np.nan])
+    result = talib.MOM(values, timeperiod=4)
+    assert isinstance(result, pl.Series)
+    assert_array_equal(result.to_numpy(), [np.nan, np.nan, np.nan])
+
+
+def test_MAVP():
+    a = pl.Series([1,5,3,4,7,3,8,1,4,6], dtype=pl.Float64)
+    b = pl.Series([2,4,2,4,2,4,2,4,2,4], dtype=pl.Float64)
+    result = talib.MAVP(a, b, minperiod=2, maxperiod=4)
+    assert isinstance(result, pl.Series)
+    assert_array_equal(result.to_numpy(), [np.nan,np.nan,np.nan,3.25,5.5,4.25,5.5,4.75,2.5,4.75])
+    sma2 = talib.SMA(a, 2)
+    assert isinstance(sma2, pl.Series)
+    assert_array_equal(result.to_numpy()[4::2], sma2.to_numpy()[4::2])
+    sma4 = talib.SMA(a, 4)
+    assert isinstance(sma4, pl.Series)
+    assert_array_equal(result.to_numpy()[3::2], sma4.to_numpy()[3::2])
+    result = talib.MAVP(a, b, minperiod=2, maxperiod=3)
+    assert isinstance(result, pl.Series)
+    assert_array_equal(result.to_numpy(), [np.nan,np.nan,4,4,5.5,4.666666666666667,5.5,4,2.5,3.6666666666666665])
+    sma3 = talib.SMA(a, 3)
+    assert isinstance(sma3, pl.Series)
+    assert_array_equal(result.to_numpy()[2::2], sma2.to_numpy()[2::2])
+    assert_array_equal(result.to_numpy()[3::2], sma3.to_numpy()[3::2])
+
+
+def test_TEVA():
+    size = 50
+    df = pl.DataFrame(
+        {
+            "open": np.random.uniform(low=0.0, high=100.0, size=size).astype("float32"),
+            "high": np.random.uniform(low=0.0, high=100.0, size=size).astype("float32"),
+            "low": np.random.uniform(low=0.0, high=100.0, size=size).astype("float32"),
+            "close": np.random.uniform(low=0.0, high=100.0, size=size).astype("float32"),
+            "volume": np.random.uniform(low=0.0, high=100.0, size=size).astype("float32")
+        }
+    )
+    tema1 = abstract.TEMA(df, timeperiod=9)
+    assert isinstance(tema1, pl.Series)
+    assert len(tema1) == 50
+    inputs = abstract.TEMA.get_input_arrays()
+    assert inputs.columns == df.columns
+    for column in df.columns:
+        assert_array_equal(inputs[column].to_numpy(), df[column].to_numpy())
+
+    tema2 = abstract.TEMA(df, timeperiod=9)
+    assert isinstance(tema2, pl.Series)
+    assert len(tema2) == 50
+    inputs = abstract.TEMA.get_input_arrays()
+    assert inputs.columns == df.columns
+    for column in df.columns:
+        assert_array_equal(inputs[column].to_numpy(), df[column].to_numpy())
+
+    assert_array_equal(tema1.to_numpy(), tema2.to_numpy())
+
+def test_AVR():
+    size = 50
+    df = pl.DataFrame(
+        {
+            "open": np.random.uniform(low=0.0, high=100.0, size=size).astype("float32"),
+            "high": np.random.uniform(low=0.0, high=100.0, size=size).astype("float32"),
+            "low": np.random.uniform(low=0.0, high=100.0, size=size).astype("float32"),
+            "close": np.random.uniform(low=0.0, high=100.0, size=size).astype("float32"),
+            "volume": np.random.uniform(low=0.0, high=100.0, size=size).astype("float32")
+        }
+    )
+    high = df['high']
+    low = df['low']
+    close = df['close']
+    atr = talib.ATR(high, low, close, timeperiod=14)
diff --git a/tests/test_stream.py b/tests/test_stream.py
new file mode 100644
index 000000000..afb99edcf
--- /dev/null
+++ b/tests/test_stream.py
@@ -0,0 +1,66 @@
+import numpy as np
+import pandas as pd
+
+from talib import stream
+
+
+def test_streaming():
+    a = np.array([1,1,2,3,5,8,13], dtype=float)
+    r = stream.MOM(a, timeperiod=1)
+    assert r == 5
+    r = stream.MOM(a, timeperiod=2)
+    assert r == 8
+    r = stream.MOM(a, timeperiod=3)
+    assert r == 10
+    r = stream.MOM(a, timeperiod=4)
+    assert r == 11
+    r = stream.MOM(a, timeperiod=5)
+    assert r == 12
+    r = stream.MOM(a, timeperiod=6)
+    assert r == 12
+    r = stream.MOM(a, timeperiod=7)
+    assert np.isnan(r)
+
+
+def test_streaming_pandas():
+    a = pd.Series([1,1,2,3,5,8,13])
+    r = stream.MOM(a, timeperiod=1)
+    assert r == 5
+    r = stream.MOM(a, timeperiod=2)
+    assert r == 8
+    r = stream.MOM(a, timeperiod=3)
+    assert r == 10
+    r = stream.MOM(a, timeperiod=4)
+    assert r == 11
+    r = stream.MOM(a, timeperiod=5)
+    assert r == 12
+    r = stream.MOM(a, timeperiod=6)
+    assert r == 12
+    r = stream.MOM(a, timeperiod=7)
+    assert np.isnan(r)
+
+
+def test_CDL3BLACKCROWS():
+    o = np.array([39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 40.32, 40.51, 38.09, 35.00])
+    h = np.array([40.84, 40.84, 40.84, 40.84, 40.84, 40.84, 40.84, 40.84, 40.84, 40.84, 40.84, 40.84, 40.84, 40.84, 41.69, 40.84, 38.12, 35.50])
+    l = np.array([35.80, 35.80, 35.80, 35.80, 35.80, 35.80, 35.80, 35.80, 35.80, 35.80, 35.80, 35.80, 35.80, 35.80, 39.26, 36.73, 33.37, 30.03])
+    c = np.array([40.29, 40.29, 40.29, 40.29, 40.29, 40.29, 40.29, 40.29, 40.29, 40.29, 40.29, 40.29, 40.29, 40.29, 40.46, 37.08, 33.37, 30.03])
+
+    r = stream.CDL3BLACKCROWS(o, h, l, c)
+    assert r == -100
+
+
+def test_CDL3BLACKCROWS_pandas():
+    o = pd.Series([39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 40.32, 40.51, 38.09, 35.00])
+    h = pd.Series([40.84, 40.84, 40.84, 40.84, 40.84, 40.84, 40.84, 40.84, 40.84, 40.84, 40.84, 40.84, 40.84, 40.84, 41.69, 40.84, 38.12, 35.50])
+    l = pd.Series([35.80, 35.80, 35.80, 35.80, 35.80, 35.80, 35.80, 35.80, 35.80, 35.80, 35.80, 35.80, 35.80, 35.80, 39.26, 36.73, 33.37, 30.03])
+    c = pd.Series([40.29, 40.29, 40.29, 40.29, 40.29, 40.29, 40.29, 40.29, 40.29, 40.29, 40.29, 40.29, 40.29, 40.29, 40.46, 37.08, 33.37, 30.03])
+
+    r = stream.CDL3BLACKCROWS(o, h, l, c)
+    assert r == -100
+
+
+def test_MAXINDEX():
+    a = np.array([1., 2, 3, 4, 5, 6, 7, 8, 7, 7, 3, 4, 5, 6, 7, 8, 9, 2, 3, 4, 5, 15])
+    r = stream.MAXINDEX(a, 10)
+    assert r == 21
diff --git a/tools/build_talib_from_source.bash b/tools/build_talib_from_source.bash
deleted file mode 100755
index 84f9572e2..000000000
--- a/tools/build_talib_from_source.bash
+++ /dev/null
@@ -1,26 +0,0 @@
-#!/bin/bash
-set -e
-
-if [[ -z $1 ]]; then
-  echo "Usage: $0 deps_dir"
-  exit 1
-fi
-
-DEPS_DIR=$1
-
-TA_LIB_TGZ="ta-lib-0.4.0-src.tar.gz"
-TA_LIB_URL="http://prdownloads.sourceforge.net/ta-lib/$TA_LIB_TGZ"
-
-if [[ -d $DEPS_DIR/lib ]]; then
-  echo "Already built"
-  exit 0
-fi
-mkdir -p $DEPS_DIR/tmp
-wget -O "$DEPS_DIR/tmp/$TA_LIB_TGZ" $TA_LIB_URL
-pushd $DEPS_DIR/tmp
-tar -zxvf $TA_LIB_TGZ
-popd
-pushd $DEPS_DIR/tmp/ta-lib
-./configure --prefix=$DEPS_DIR
-make install
-popd
diff --git a/tools/build_talib_linux.sh b/tools/build_talib_linux.sh
new file mode 100644
index 000000000..cc57df507
--- /dev/null
+++ b/tools/build_talib_linux.sh
@@ -0,0 +1,53 @@
+#!/bin/bash
+
+TALIB_C_VER="${TALIB_C_VER:=0.6.4}"
+CMAKE_GENERATOR="Unix Makefiles"
+CMAKE_BUILD_TYPE=Release
+CMAKE_CONFIGURATION_TYPES=Release
+
+# Download TA-Lib C Library
+curl -L -o talib-${TALIB_C_VER}.zip https://github.com/TA-Lib/ta-lib/archive/refs/tags/v${TALIB_C_VER}.zip
+if [ $? -ne 0 ]; then
+    echo "Failed to download TA-Lib C library"
+    exit 1
+fi
+
+# Unzip TA-Lib C
+unzip -q talib-${TALIB_C_VER}.zip
+if [ $? -ne 0 ]; then
+    echo "Failed to extract TA-Lib C library"
+    exit 1
+fi
+
+# cd to TA-Lib C
+cd ta-lib-${TALIB_C_VER}
+
+# Copy TA-Lib C headers to TA-Lib Python
+mkdir -p include/ta-lib/
+cp include/*.h include/ta-lib/
+
+# Create build directory
+mkdir -p _build
+cd _build
+
+# Use CMake to configure the build
+cmake -G "$CMAKE_GENERATOR" -DCMAKE_BUILD_TYPE=$CMAKE_BUILD_TYPE -DCMAKE_INSTALL_PREFIX=../../ta-lib-install ..
+if [ $? -ne 0 ]; then
+    echo "CMake configuration failed"
+    exit 1
+fi
+
+# Compile TA-Lib
+make
+if [ $? -ne 0 ]; then
+    echo "Build failed"
+    exit 1
+fi
+
+make install
+if [ $? -ne 0 ]; then
+    echo "Install failed"
+    exit 1
+fi
+
+echo "TA-Lib build completed successfully!"
diff --git a/tools/build_talib_macos.sh b/tools/build_talib_macos.sh
new file mode 100644
index 000000000..cc57df507
--- /dev/null
+++ b/tools/build_talib_macos.sh
@@ -0,0 +1,53 @@
+#!/bin/bash
+
+TALIB_C_VER="${TALIB_C_VER:=0.6.4}"
+CMAKE_GENERATOR="Unix Makefiles"
+CMAKE_BUILD_TYPE=Release
+CMAKE_CONFIGURATION_TYPES=Release
+
+# Download TA-Lib C Library
+curl -L -o talib-${TALIB_C_VER}.zip https://github.com/TA-Lib/ta-lib/archive/refs/tags/v${TALIB_C_VER}.zip
+if [ $? -ne 0 ]; then
+    echo "Failed to download TA-Lib C library"
+    exit 1
+fi
+
+# Unzip TA-Lib C
+unzip -q talib-${TALIB_C_VER}.zip
+if [ $? -ne 0 ]; then
+    echo "Failed to extract TA-Lib C library"
+    exit 1
+fi
+
+# cd to TA-Lib C
+cd ta-lib-${TALIB_C_VER}
+
+# Copy TA-Lib C headers to TA-Lib Python
+mkdir -p include/ta-lib/
+cp include/*.h include/ta-lib/
+
+# Create build directory
+mkdir -p _build
+cd _build
+
+# Use CMake to configure the build
+cmake -G "$CMAKE_GENERATOR" -DCMAKE_BUILD_TYPE=$CMAKE_BUILD_TYPE -DCMAKE_INSTALL_PREFIX=../../ta-lib-install ..
+if [ $? -ne 0 ]; then
+    echo "CMake configuration failed"
+    exit 1
+fi
+
+# Compile TA-Lib
+make
+if [ $? -ne 0 ]; then
+    echo "Build failed"
+    exit 1
+fi
+
+make install
+if [ $? -ne 0 ]; then
+    echo "Install failed"
+    exit 1
+fi
+
+echo "TA-Lib build completed successfully!"
diff --git a/tools/build_talib_windows.cmd b/tools/build_talib_windows.cmd
new file mode 100644
index 000000000..ad994d948
--- /dev/null
+++ b/tools/build_talib_windows.cmd
@@ -0,0 +1,38 @@
+:: Download and build TA-Lib 
+@echo on
+
+if not defined TALIB_C_VER set TALIB_C_VER=0.6.4
+
+set CMAKE_GENERATOR=NMake Makefiles
+set CMAKE_BUILD_TYPE=Release
+set CMAKE_CONFIGURATION_TYPES=Release
+
+curl -L -o talib-%TALIB_C_VER%.zip https://github.com/TA-Lib/ta-lib/archive/refs/tags/v%TALIB_C_VER%.zip
+if errorlevel 1 exit /B 1
+
+tar -xzvf talib-%TALIB_C_VER%.zip
+if errorlevel 1 exit /B 1
+
+:: git apply --verbose --binary talib.diff
+:: if errorlevel 1 exit /B 1
+
+:: set MSBUILDTREATHIGHERTOOLSVERSIONASCURRENT
+
+setlocal
+cd ta-lib-%TALIB_C_VER%
+
+mkdir  include\ta-lib
+copy /Y include\*.* include\ta-lib
+
+md _build
+cd _build
+
+cmake.exe ..
+if errorlevel 1 exit /B 1
+
+nmake.exe /nologo all
+if errorlevel 1 exit /B 1
+
+copy /Y /B ta-lib-static.lib ta-lib.lib
+
+endlocal
diff --git a/tools/example.py b/tools/example.py
index 87c35b522..75a6d3fc1 100644
--- a/tools/example.py
+++ b/tools/example.py
@@ -1,5 +1,3 @@
-from __future__ import print_function
-
 import sys
 import numpy as np
 import pylab
diff --git a/tools/generate_func.py b/tools/generate_func.py
index 4a8b44496..6dbb4b100 100644
--- a/tools/generate_func.py
+++ b/tools/generate_func.py
@@ -1,5 +1,3 @@
-from __future__ import print_function
-
 import os
 import re
 import sys
@@ -11,11 +9,27 @@
 # FIXME: don't return number of elements since it always equals allocation?
 
 functions = []
-include_paths = ['/usr/include', '/usr/local/include', '/opt/include', '/opt/local/include']
 if sys.platform == 'win32':
-    include_paths = [r'c:\ta-lib\c\include']
+    include_dirs = [
+        r"c:\ta-lib\c\include",
+        r"c:\Program Files\TA-Lib\include",
+        r"c:\Program Files (x86)\TA-Lib\include",
+    ]
+else:
+    include_dirs = [
+        '/usr/include',
+        '/usr/local/include',
+        '/opt/include',
+        '/opt/local/include',
+        '/opt/homebrew/include',
+        '/opt/homebrew/opt/ta-lib/include',
+    ]
+
+if 'TA_INCLUDE_PATH' in os.environ:
+    include_dirs = os.environ['TA_INCLUDE_PATH'].split(os.pathsep)
+
 header_found = False
-for path in include_paths:
+for path in include_dirs:
     ta_func_header = os.path.join(path, 'ta-lib', 'ta_func.h')
     if os.path.exists(ta_func_header):
         header_found = True
@@ -26,15 +40,17 @@
 with open(ta_func_header) as f:
     tmp = []
     for line in f:
+        if line.startswith('TA_LIB_API'):
+            line = line[10:]
         line = line.strip()
         if tmp or \
             line.startswith('TA_RetCode TA_') or \
             line.startswith('int TA_'):
-            line = re.sub('/\*[^\*]+\*/', '', line) # strip comments
+            line = re.sub(r'/\*[^\*]+\*/', '', line) # strip comments
             tmp.append(line)
             if not line:
                 s = ' '.join(tmp)
-                s = re.sub('\s+', ' ', s)
+                s = re.sub(r'\s+', ' ', s)
                 functions.append(s)
                 tmp = []
 
@@ -71,7 +87,7 @@
         raise Exception("input array type is not double")
     if real.ndim != 1:
         raise Exception("input array has wrong dimensions")
-    if not (PyArray_FLAGS(real) & np.NPY_C_CONTIGUOUS):
+    if not (PyArray_FLAGS(real) & np.NPY_ARRAY_C_CONTIGUOUS):
         real = PyArray_GETCONTIGUOUS(real)
     return real
 
@@ -105,7 +121,7 @@
         raise Exception("input array lengths are different")
     return length
 
-cdef np.npy_int check_begidx1(np.npy_intp length, double* a1) except -1:
+cdef np.npy_int check_begidx1(np.npy_intp length, double* a1):
     cdef:
         double val
     for i from 0 <= i < length:
@@ -114,9 +130,9 @@
             continue
         return i
     else:
-        raise Exception("inputs are all NaN")
+        return length - 1
 
-cdef np.npy_int check_begidx2(np.npy_intp length, double* a1, double* a2) except -1:
+cdef np.npy_int check_begidx2(np.npy_intp length, double* a1, double* a2):
     cdef:
         double val
     for i from 0 <= i < length:
@@ -128,9 +144,9 @@
             continue
         return i
     else:
-        raise Exception("inputs are all NaN")
+        return length - 1
 
-cdef np.npy_int check_begidx3(np.npy_intp length, double* a1, double* a2, double* a3) except -1:
+cdef np.npy_int check_begidx3(np.npy_intp length, double* a1, double* a2, double* a3):
     cdef:
         double val
     for i from 0 <= i < length:
@@ -145,9 +161,9 @@
             continue
         return i
     else:
-        raise Exception("inputs are all NaN")
+        return length - 1
 
-cdef np.npy_int check_begidx4(np.npy_intp length, double* a1, double* a2, double* a3, double* a4) except -1:
+cdef np.npy_int check_begidx4(np.npy_intp length, double* a1, double* a2, double* a3, double* a4):
     cdef:
         double val
     for i from 0 <= i < length:
@@ -165,13 +181,13 @@
             continue
         return i
     else:
-        raise Exception("inputs are all NaN")
+        return length - 1
 
 cdef np.ndarray make_double_array(np.npy_intp length, int lookback):
     cdef:
         np.ndarray outreal
         double* outreal_data
-    outreal = PyArray_EMPTY(1, &length, np.NPY_DOUBLE, np.NPY_DEFAULT)
+    outreal = PyArray_EMPTY(1, &length, np.NPY_DOUBLE, np.NPY_ARRAY_DEFAULT)
     outreal_data = <double*>outreal.data
     for i from 0 <= i < min(lookback, length):
         outreal_data[i] = NaN
@@ -181,7 +197,7 @@
     cdef:
         np.ndarray outinteger
         int* outinteger_data
-    outinteger = PyArray_EMPTY(1, &length, np.NPY_INT32, np.NPY_DEFAULT)
+    outinteger = PyArray_EMPTY(1, &length, np.NPY_INT32, np.NPY_ARRAY_DEFAULT)
     outinteger_data = <int*>outinteger.data
     for i from 0 <= i < min(lookback, length):
         outinteger_data[i] = 0
@@ -207,12 +223,16 @@ def cleanup(name):
     i = f.index('(')
     name = f[:i].split()[1]
     args = f[i:].split(',')
-    args = [re.sub('[\(\);]', '', s).strip() for s in args]
+    args = [re.sub(r'[\(\);]', '', s).strip() for s in args]
 
     shortname = name[3:]
     names.append(shortname)
-    func_info = abstract.Function(shortname).info
-    defaults, documentation = abstract._get_defaults_and_docs(func_info)
+    try:
+        func_info = abstract.Function(shortname).info
+        defaults, documentation = abstract._get_defaults_and_docs(func_info)
+    except:
+        print("cannot find defaults and docs for", shortname, file=sys.stderr)
+        defaults, documentation = {}, ""
 
     print('@wraparound(False)  # turn off relative indexing from end of lists')
     print('@boundscheck(False) # turn off bounds-checking for entire function')
@@ -255,7 +275,7 @@ def cleanup(name):
                 else:
                     print('int %s=-2**31' % var, end=' ')   # TA_INTEGER_DEFAULT
             elif arg.startswith('TA_MAType'):
-                print('int %s=0' % var, end=' ')            # TA_MAType_SMA
+                print('int %s=%s' % (var, defaults.get('matype', 0)), end=' ') # TA_MAType_SMA
             else:
                 assert False, arg
             if '[, ' not in docs:
@@ -269,6 +289,7 @@ def cleanup(name):
         lower_case = False
         documentation = documentation.split('\n')[2:] # discard abstract calling definition
         for line in documentation:
+            line = line.replace('Substraction', 'Subtraction')
             if 'prices' not in line and 'price' in line:
                 line = line.replace('price', 'real')
             if not line or line.isspace():
@@ -381,6 +402,18 @@ def cleanup(name):
 
     print(')')
     print('    _ta_check_success("%s", retCode)' % name)
+    if 'INDEX' in f:
+        for arg in args:
+            var = arg.split()[-1]
+
+            if 'out' not in var:
+                continue
+
+            if var.endswith('[]'):
+                var = cleanup(var[:-2])
+                print('    %s_data = <int*>%s.data' % (var, var))
+                print('    for i from lookback <= i < length:')
+                print('        %s_data[i] += begidx' % var)
     print('    return ', end='')
     i = 0
     for arg in args:
diff --git a/tools/generate_stream.py b/tools/generate_stream.py
index 7b8a337b5..7d6af3f68 100644
--- a/tools/generate_stream.py
+++ b/tools/generate_stream.py
@@ -1,5 +1,3 @@
-from __future__ import print_function
-
 import os
 import re
 import sys
@@ -11,11 +9,27 @@
 # FIXME: don't return number of elements since it always equals allocation?
 
 functions = []
-include_paths = ['/usr/include', '/usr/local/include', '/opt/include', '/opt/local/include']
 if sys.platform == 'win32':
-    include_paths = [r'c:\ta-lib\c\include']
+    include_dirs = [
+        r"c:\ta-lib\c\include",
+        r"c:\Program Files\TA-Lib\include",
+        r"c:\Program Files (x86)\TA-Lib\include",
+    ]
+else:
+    include_dirs = [
+        '/usr/include',
+        '/usr/local/include',
+        '/opt/include',
+        '/opt/local/include',
+        '/opt/homebrew/include',
+        '/opt/homebrew/opt/ta-lib/include',
+    ]
+
+if 'TA_INCLUDE_PATH' in os.environ:
+    include_dirs = os.environ['TA_INCLUDE_PATH'].split(os.pathsep)
+
 header_found = False
-for path in include_paths:
+for path in include_dirs:
     ta_func_header = os.path.join(path, 'ta-lib', 'ta_func.h')
     if os.path.exists(ta_func_header):
         header_found = True
@@ -26,15 +40,17 @@
 with open(ta_func_header) as f:
     tmp = []
     for line in f:
+        if line.startswith('TA_LIB_API'):
+            line = line[10:]
         line = line.strip()
         if tmp or \
             line.startswith('TA_RetCode TA_') or \
             line.startswith('int TA_'):
-            line = re.sub('/\*[^\*]+\*/', '', line) # strip comments
+            line = re.sub(r'/\*[^\*]+\*/', '', line) # strip comments
             tmp.append(line)
             if not line:
                 s = ' '.join(tmp)
-                s = re.sub('\s+', ' ', s)
+                s = re.sub(r'\s+', ' ', s)
                 functions.append(s)
                 tmp = []
 
@@ -52,8 +68,8 @@
 cimport _ta_lib as lib
 from _ta_lib cimport TA_RetCode
 # NOTE: _ta_check_success, NaN are defined in common.pxi
-#       NumPy C API is initialize in _func.pxi
 
+np.import_array() # Initialize the NumPy C API
 """)
 
 # cleanup variable names to make them more pythonic
@@ -74,12 +90,16 @@ def cleanup(name):
     i = f.index('(')
     name = f[:i].split()[1]
     args = f[i:].split(',')
-    args = [re.sub('[\(\);]', '', s).strip() for s in args]
+    args = [re.sub(r'[\(\);]', '', s).strip() for s in args]
 
     shortname = name[3:]
     names.append(shortname)
-    func_info = abstract.Function(shortname).info
-    defaults, documentation = abstract._get_defaults_and_docs(func_info)
+    try:
+        func_info = abstract.Function(shortname).info
+        defaults, documentation = abstract._get_defaults_and_docs(func_info)
+    except:
+        print("cannot find defaults and docs for", shortname, file=sys.stderr)
+        defaults, documentation = {}, ""
 
     print('@wraparound(False)  # turn off relative indexing from end of lists')
     print('@boundscheck(False) # turn off bounds-checking for entire function')
@@ -122,7 +142,7 @@ def cleanup(name):
                 else:
                     print('int %s=-2**31' % var, end=' ')   # TA_INTEGER_DEFAULT
             elif arg.startswith('TA_MAType'):
-                print('int %s=0' % var, end=' ')            # TA_MAType_SMA
+                print('int %s=%s' % (var, defaults.get('matype', 0)), end=' ') # TA_MAType_SMA
             else:
                 assert False, arg
             if '[, ' not in docs:
@@ -136,6 +156,7 @@ def cleanup(name):
         lower_case = False
         documentation = documentation.split('\n')[2:] # discard abstract calling definition
         for line in documentation:
+            line = line.replace('Substraction', 'Subtraction')
             if 'prices' not in line and 'price' in line:
                 line = line.replace('price', 'real')
             if not line or line.isspace():
diff --git a/tools/perf_talib.py b/tools/perf_talib.py
index 5a3377d4a..010d00bad 100644
--- a/tools/perf_talib.py
+++ b/tools/perf_talib.py
@@ -1,7 +1,6 @@
-from __future__ import print_function
-
 import numpy
 import talib
+import time
 import sys
 
 TEST_LEN = int(sys.argv[1]) if len(sys.argv) > 1 else 10000
@@ -12,7 +11,6 @@
 if False: # fill array with nans
     data[:-1] = numpy.nan
 
-import time
 t0 = time.time()
 for _ in range(LOOPS):
     talib.MA(data)
diff --git a/tools/threads_talib.py b/tools/threads_talib.py
new file mode 100644
index 000000000..036ae07da
--- /dev/null
+++ b/tools/threads_talib.py
@@ -0,0 +1,53 @@
+import time
+import threading
+
+import numpy
+import copy
+from talib.abstract import RSI
+import sys
+import pandas as pd
+
+TEST_LEN_SHORT = int(sys.argv[1]) if len(sys.argv) > 1 else 999
+TEST_LEN_LONG = int(sys.argv[1]) if len(sys.argv) > 1 else 4005
+LOOPS = int(sys.argv[2]) if len(sys.argv) > 2 else 1000
+
+data_short = numpy.random.rand(TEST_LEN_SHORT, 5)
+data_long = numpy.random.rand(TEST_LEN_LONG, 5)
+
+df_short = pd.DataFrame(data_short, columns={
+                        'open', 'high', 'low', 'close', 'volume'})
+df_long = pd.DataFrame(data_long, columns={
+                       'open', 'high', 'low', 'close', 'volume'})
+
+total = 0
+
+
+def loop():
+    global total
+    if threading.get_native_id() % 2 == 0:
+        df = copy.deepcopy(df_short)
+    else:
+        df = copy.deepcopy(df_long)
+
+    while total < LOOPS:
+        total += 1
+        try:
+            df['RSI'] = RSI(df)
+        except ValueError as msg:
+            raise ValueError(msg)
+
+
+t0 = time.time()
+
+threads = []
+for i in range(4):
+    t = threading.Thread(target=loop)
+    threads.append(t)
+    t.start()
+
+for t in threads:
+    t.join()
+t1 = time.time()
+print('test_len: %d, loops: %d' % (TEST_LEN_LONG, LOOPS))
+print('%.6f' % (t1 - t0))
+print('%.6f' % ((t1 - t0) / LOOPS))