diff --git a/CMakeLists.txt b/CMakeLists.txt
index d8ff22b..1c4c542 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -38,13 +38,6 @@ ADD_DEFINITIONS(
 ENDIF()
 ENDIF()
 
-SET (ENABLE_FFTW3 OFF CACHE BOOL "Use fftw3 instead of liquid-dsp internal fft.")
-IF(ENABLE_FFTW3)
-    ADD_DEFINITIONS(
-        -DUSE_FFTW3=1
-    )
-ENDIF()
-
 set(USE_HAMLIB OFF CACHE BOOL "Support hamlib for radio control functions.")
 
 if (USE_HAMLIB)
@@ -111,11 +104,6 @@ SET( CMAKE_RUNTIME_OUTPUT_DIRECTORY_RELEASE ${PROJECT_BINARY_DIR}/${EX_PLATFORM_
 
 IF (MSVC) 
 	include_directories ("${PROJECT_SOURCE_DIR}/external/wglext")
-    IF(ENABLE_FFTW3)
-    	SET(FFTW_INCLUDES "${PROJECT_SOURCE_DIR}/external/fftw-3.3.4/" CACHE STRING "FFTW Include Directory")
-    	SET(FFTW_LIBRARIES "${PROJECT_SOURCE_DIR}/external/fftw-3.3.4/${EX_PLATFORM}/libfftw3f-3.lib" CACHE STRING "FFTW Library")
-    	SET(FFTW_DLL "${PROJECT_SOURCE_DIR}/external/fftw-3.3.4/${EX_PLATFORM}/libfftw3f-3.dll" CACHE STRING "FFTW DLL")
-    ENDIF()
 	SET(LIQUID_INCLUDES "${PROJECT_SOURCE_DIR}/external/liquid-dsp/include/" CACHE STRING "Liquid-DSP include directory")
 	SET(LIQUID_LIBRARIES "${PROJECT_SOURCE_DIR}/external/liquid-dsp/msvc/${EX_PLATFORM}/libliquid.lib" CACHE STRING "Liquid-DSP Library")
 	SET(LIQUID_DLL "${PROJECT_SOURCE_DIR}/external/liquid-dsp/msvc/${EX_PLATFORM}/libliquid.dll" CACHE STRING "Liquid-DSP DLL")
@@ -128,13 +116,6 @@ ELSE (MSVC)
 ENDIF(MSVC)
 
 find_package(OpenGL REQUIRED)
-
-IF(ENABLE_FFTW3)
-    find_package(FFTW REQUIRED)
-    include_directories(${FFTW_INCLUDES})
-    SET(OTHER_LIBRARIES ${OTHER_LIBRARIES} ${FFTW_LIBRARIES})
-ENDIF()
-
 find_package(Liquid REQUIRED)
 include_directories(${LIQUID_INCLUDES})
 SET(OTHER_LIBRARIES ${OTHER_LIBRARIES} ${LIQUID_LIBRARIES})
@@ -202,10 +183,6 @@ IF (UNIX AND NOT APPLE)
     SET(USE_AUDIO_ALSA OFF CACHE BOOL "Use ALSA Audio")
     SET(USE_AUDIO_OSS OFF CACHE BOOL "Use OSS Audio")
   
-    IF(ENABLE_FFTW3)
-        SET(FFTW_LIB fftw3f)
-    ENDIF()
-
     SET(LIQUID_LIB liquid)
     SET(OTHER_LIBRARIES ${OTHER_LIBRARIES} dl)
 
@@ -247,10 +224,6 @@ ENDIF(UNIX AND NOT APPLE)
 IF (APPLE)
     SET(CMAKE_OSX_DEPLOYMENT_TARGET, "10.9")
   
-    IF(ENABLE_FFTW3)
-        SET(FFTW_LIB fftw3f)
-    ENDIF()
-
     SET(LIQUID_LIB liquid)
     link_directories(/usr/local/lib)
     link_directories(/opt/local/lib)
@@ -586,15 +559,9 @@ IF (NOT BUNDLE_APP)
     configure_files(${PROJECT_SOURCE_DIR}/font ${CMAKE_BINARY_DIR}/${EX_PLATFORM_NAME}/fonts "*.png")
     configure_files(${PROJECT_SOURCE_DIR}/icon ${CMAKE_BINARY_DIR}/${EX_PLATFORM_NAME} CubicSDR.ico)
 	IF(MSVC)	
-        IF(ENABLE_FFTW3)
-            configure_files(${PROJECT_SOURCE_DIR}/external/fftw-3.3.4/${EX_PLATFORM}/ ${CMAKE_BINARY_DIR}/${EX_PLATFORM_NAME} "*.dll")
-        ENDIF()
 		configure_files(${PROJECT_SOURCE_DIR}/external/liquid-dsp/msvc/${EX_PLATFORM}/ ${CMAKE_BINARY_DIR}/${EX_PLATFORM_NAME} "*.dll")
 	ENDIF()
     add_executable(CubicSDR ${cubicsdr_sources} ${cubicsdr_headers} ${RES_FILES})
-    IF(ENABLE_FFTW3)
-        target_link_libraries(CubicSDR ${FFTW_LIB})
-    ENDIF()
     target_link_libraries(CubicSDR ${LIQUID_LIB} ${wxWidgets_LIBRARIES} ${OPENGL_LIBRARIES} ${OTHER_LIBRARIES})
 ENDIF (NOT BUNDLE_APP)
 
@@ -666,10 +633,6 @@ IF (APPLE AND BUNDLE_APP)
         MACOSX_PACKAGE_LOCATION Resources/fonts
     )
 
-    IF(ENABLE_FFTW3)
-        target_link_libraries(CubicSDR ${FFTW_LIB})    
-    ENDIF()
-    
     target_link_libraries(CubicSDR ${LIQUID_LIB} ${wxWidgets_LIBRARIES} ${OPENGL_LIBRARIES} ${OTHER_LIBRARIES})
     SET_TARGET_PROPERTIES(CubicSDR PROPERTIES
         MACOSX_BUNDLE TRUE
@@ -811,12 +774,6 @@ IF (WIN32 AND NOT BUILD_INSTALLER)
 		${LIQUID_DLL}
 	DESTINATION bin)
 
-    IF(ENABLE_FFTW3)
-    	INSTALL(FILES 		
-    		${FFTW_DLL}
-    	DESTINATION bin)
-    ENDIF()
-	
 	IF(USE_HAMLIB)
 		FOREACH(HAMLIB_DLL ${HAMLIB_DLLS})
 			message(STATUS "Copying Hamlib DLL: ${HAMLIB_DLL}")
@@ -879,13 +836,6 @@ IF (WIN32 AND BUILD_INSTALLER)
 		ENDFOREACH()
 	ENDIF()
 
-		
-    IF(ENABLE_FFTW3)
-    	install(FILES 
-    		${FFTW_DLL}
-        DESTINATION .)
-    ENDIF()
-        
 	IF (BUNDLE_SOAPY_MODS)
 		ADD_DEFINITIONS(
 			-DBUNDLE_SOAPY_MODS=1
@@ -927,9 +877,6 @@ IF (UNIX AND NOT APPLE AND BUILD_DEB)
     set(CPACK_GENERATOR DEB)
 	set(CPACK_PACKAGE_NAME "CubicSDR")
 	SET(CPACK_DEBIAN_PACKAGE_DEPENDS " libwxgtk3.0-0, libpulse0")
-    IF(ENABLE_FFTW3)
-    	SET(CPACK_DEBIAN_PACKAGE_DEPENDS "${CPACK_DEBIAN_PACKAGE_DEPENDS}, libfftw3-single3")    
-    ENDIF()
  	SET(CPACK_DEBIAN_PACKAGE_MAINTAINER "Charles J. Cliffe <cj@cubicproductions.com>")
 	SET(CPACK_DEBIAN_PACKAGE_DESCRIPTION "CubicSDR Software Defined Radio application v${CUBICSDR_VERSION}")
 	SET(CPACK_DEBIAN_PACKAGE_SECTION "comm")
diff --git a/cmake/Modules/FindFFTW.cmake b/cmake/Modules/FindFFTW.cmake
deleted file mode 100644
index 0a4c607..0000000
--- a/cmake/Modules/FindFFTW.cmake
+++ /dev/null
@@ -1,22 +0,0 @@
-# - Find FFTW
-# Find the native FFTW includes and library
-#
-#  FFTW_INCLUDES    - where to find fftw3.h
-#  FFTW_LIBRARIES   - List of libraries when using FFTW.
-#  FFTW_FOUND       - True if FFTW found.
-
-if (FFTW_INCLUDES)
-  # Already in cache, be silent
-  set (FFTW_FIND_QUIETLY TRUE)
-endif (FFTW_INCLUDES)
-
-find_path (FFTW_INCLUDES fftw3.h)
-
-find_library (FFTW_LIBRARIES NAMES fftw3)
-
-# handle the QUIETLY and REQUIRED arguments and set FFTW_FOUND to TRUE if
-# all listed variables are TRUE
-include (FindPackageHandleStandardArgs)
-find_package_handle_standard_args (FFTW DEFAULT_MSG FFTW_LIBRARIES FFTW_INCLUDES)
-
-#mark_as_advanced (FFTW_LIBRARIES FFTW_INCLUDES)
diff --git a/external/fftw-3.3.4/32/libfftw3f-3.dll b/external/fftw-3.3.4/32/libfftw3f-3.dll
deleted file mode 100644
index e40d992..0000000
Binary files a/external/fftw-3.3.4/32/libfftw3f-3.dll and /dev/null differ
diff --git a/external/fftw-3.3.4/32/libfftw3f-3.exp b/external/fftw-3.3.4/32/libfftw3f-3.exp
deleted file mode 100644
index 2083356..0000000
Binary files a/external/fftw-3.3.4/32/libfftw3f-3.exp and /dev/null differ
diff --git a/external/fftw-3.3.4/32/libfftw3f-3.lib b/external/fftw-3.3.4/32/libfftw3f-3.lib
deleted file mode 100644
index 475cf8f..0000000
Binary files a/external/fftw-3.3.4/32/libfftw3f-3.lib and /dev/null differ
diff --git a/external/fftw-3.3.4/64/libfftw3f-3.a b/external/fftw-3.3.4/64/libfftw3f-3.a
deleted file mode 100644
index 587b961..0000000
Binary files a/external/fftw-3.3.4/64/libfftw3f-3.a and /dev/null differ
diff --git a/external/fftw-3.3.4/64/libfftw3f-3.def b/external/fftw-3.3.4/64/libfftw3f-3.def
deleted file mode 100644
index d6be854..0000000
--- a/external/fftw-3.3.4/64/libfftw3f-3.def
+++ /dev/null
@@ -1,1013 +0,0 @@
-LIBRARY libfftw3f-3.dll
-EXPORTS
-fftwf_alignment_of
-fftwf_alloc_complex
-fftwf_alloc_real
-fftwf_assertion_failed
-fftwf_bufdist
-fftwf_check_alignment_of_sse2_pm
-fftwf_choose_radix
-fftwf_cleanup
-fftwf_cleanup_threads
-fftwf_codelet_e01_8
-fftwf_codelet_e10_8
-fftwf_codelet_hb2_16
-fftwf_codelet_hb2_20
-fftwf_codelet_hb2_25
-fftwf_codelet_hb2_32
-fftwf_codelet_hb2_4
-fftwf_codelet_hb2_5
-fftwf_codelet_hb2_8
-fftwf_codelet_hb_10
-fftwf_codelet_hb_12
-fftwf_codelet_hb_15
-fftwf_codelet_hb_16
-fftwf_codelet_hb_2
-fftwf_codelet_hb_20
-fftwf_codelet_hb_25
-fftwf_codelet_hb_3
-fftwf_codelet_hb_32
-fftwf_codelet_hb_4
-fftwf_codelet_hb_5
-fftwf_codelet_hb_6
-fftwf_codelet_hb_64
-fftwf_codelet_hb_7
-fftwf_codelet_hb_8
-fftwf_codelet_hb_9
-fftwf_codelet_hc2cb2_16
-fftwf_codelet_hc2cb2_20
-fftwf_codelet_hc2cb2_32
-fftwf_codelet_hc2cb2_4
-fftwf_codelet_hc2cb2_8
-fftwf_codelet_hc2cb_10
-fftwf_codelet_hc2cb_12
-fftwf_codelet_hc2cb_16
-fftwf_codelet_hc2cb_2
-fftwf_codelet_hc2cb_20
-fftwf_codelet_hc2cb_32
-fftwf_codelet_hc2cb_4
-fftwf_codelet_hc2cb_6
-fftwf_codelet_hc2cb_8
-fftwf_codelet_hc2cbdft2_16
-fftwf_codelet_hc2cbdft2_20
-fftwf_codelet_hc2cbdft2_32
-fftwf_codelet_hc2cbdft2_4
-fftwf_codelet_hc2cbdft2_8
-fftwf_codelet_hc2cbdft_10
-fftwf_codelet_hc2cbdft_12
-fftwf_codelet_hc2cbdft_16
-fftwf_codelet_hc2cbdft_2
-fftwf_codelet_hc2cbdft_20
-fftwf_codelet_hc2cbdft_32
-fftwf_codelet_hc2cbdft_4
-fftwf_codelet_hc2cbdft_6
-fftwf_codelet_hc2cbdft_8
-fftwf_codelet_hc2cbdftv_10_avx
-fftwf_codelet_hc2cbdftv_10_sse2
-fftwf_codelet_hc2cbdftv_12_avx
-fftwf_codelet_hc2cbdftv_12_sse2
-fftwf_codelet_hc2cbdftv_16_avx
-fftwf_codelet_hc2cbdftv_16_sse2
-fftwf_codelet_hc2cbdftv_20_avx
-fftwf_codelet_hc2cbdftv_20_sse2
-fftwf_codelet_hc2cbdftv_2_avx
-fftwf_codelet_hc2cbdftv_2_sse2
-fftwf_codelet_hc2cbdftv_32_avx
-fftwf_codelet_hc2cbdftv_32_sse2
-fftwf_codelet_hc2cbdftv_4_avx
-fftwf_codelet_hc2cbdftv_4_sse2
-fftwf_codelet_hc2cbdftv_6_avx
-fftwf_codelet_hc2cbdftv_6_sse2
-fftwf_codelet_hc2cbdftv_8_avx
-fftwf_codelet_hc2cbdftv_8_sse2
-fftwf_codelet_hc2cf2_16
-fftwf_codelet_hc2cf2_20
-fftwf_codelet_hc2cf2_32
-fftwf_codelet_hc2cf2_4
-fftwf_codelet_hc2cf2_8
-fftwf_codelet_hc2cf_10
-fftwf_codelet_hc2cf_12
-fftwf_codelet_hc2cf_16
-fftwf_codelet_hc2cf_2
-fftwf_codelet_hc2cf_20
-fftwf_codelet_hc2cf_32
-fftwf_codelet_hc2cf_4
-fftwf_codelet_hc2cf_6
-fftwf_codelet_hc2cf_8
-fftwf_codelet_hc2cfdft2_16
-fftwf_codelet_hc2cfdft2_20
-fftwf_codelet_hc2cfdft2_32
-fftwf_codelet_hc2cfdft2_4
-fftwf_codelet_hc2cfdft2_8
-fftwf_codelet_hc2cfdft_10
-fftwf_codelet_hc2cfdft_12
-fftwf_codelet_hc2cfdft_16
-fftwf_codelet_hc2cfdft_2
-fftwf_codelet_hc2cfdft_20
-fftwf_codelet_hc2cfdft_32
-fftwf_codelet_hc2cfdft_4
-fftwf_codelet_hc2cfdft_6
-fftwf_codelet_hc2cfdft_8
-fftwf_codelet_hc2cfdftv_10_avx
-fftwf_codelet_hc2cfdftv_10_sse2
-fftwf_codelet_hc2cfdftv_12_avx
-fftwf_codelet_hc2cfdftv_12_sse2
-fftwf_codelet_hc2cfdftv_16_avx
-fftwf_codelet_hc2cfdftv_16_sse2
-fftwf_codelet_hc2cfdftv_20_avx
-fftwf_codelet_hc2cfdftv_20_sse2
-fftwf_codelet_hc2cfdftv_2_avx
-fftwf_codelet_hc2cfdftv_2_sse2
-fftwf_codelet_hc2cfdftv_32_avx
-fftwf_codelet_hc2cfdftv_32_sse2
-fftwf_codelet_hc2cfdftv_4_avx
-fftwf_codelet_hc2cfdftv_4_sse2
-fftwf_codelet_hc2cfdftv_6_avx
-fftwf_codelet_hc2cfdftv_6_sse2
-fftwf_codelet_hc2cfdftv_8_avx
-fftwf_codelet_hc2cfdftv_8_sse2
-fftwf_codelet_hf2_16
-fftwf_codelet_hf2_20
-fftwf_codelet_hf2_25
-fftwf_codelet_hf2_32
-fftwf_codelet_hf2_4
-fftwf_codelet_hf2_5
-fftwf_codelet_hf2_8
-fftwf_codelet_hf_10
-fftwf_codelet_hf_12
-fftwf_codelet_hf_15
-fftwf_codelet_hf_16
-fftwf_codelet_hf_2
-fftwf_codelet_hf_20
-fftwf_codelet_hf_25
-fftwf_codelet_hf_3
-fftwf_codelet_hf_32
-fftwf_codelet_hf_4
-fftwf_codelet_hf_5
-fftwf_codelet_hf_6
-fftwf_codelet_hf_64
-fftwf_codelet_hf_7
-fftwf_codelet_hf_8
-fftwf_codelet_hf_9
-fftwf_codelet_n1_10
-fftwf_codelet_n1_11
-fftwf_codelet_n1_12
-fftwf_codelet_n1_13
-fftwf_codelet_n1_14
-fftwf_codelet_n1_15
-fftwf_codelet_n1_16
-fftwf_codelet_n1_2
-fftwf_codelet_n1_20
-fftwf_codelet_n1_25
-fftwf_codelet_n1_3
-fftwf_codelet_n1_32
-fftwf_codelet_n1_4
-fftwf_codelet_n1_5
-fftwf_codelet_n1_6
-fftwf_codelet_n1_64
-fftwf_codelet_n1_7
-fftwf_codelet_n1_8
-fftwf_codelet_n1_9
-fftwf_codelet_n1bv_10_avx
-fftwf_codelet_n1bv_10_sse2
-fftwf_codelet_n1bv_11_avx
-fftwf_codelet_n1bv_11_sse2
-fftwf_codelet_n1bv_128_avx
-fftwf_codelet_n1bv_128_sse2
-fftwf_codelet_n1bv_12_avx
-fftwf_codelet_n1bv_12_sse2
-fftwf_codelet_n1bv_13_avx
-fftwf_codelet_n1bv_13_sse2
-fftwf_codelet_n1bv_14_avx
-fftwf_codelet_n1bv_14_sse2
-fftwf_codelet_n1bv_15_avx
-fftwf_codelet_n1bv_15_sse2
-fftwf_codelet_n1bv_16_avx
-fftwf_codelet_n1bv_16_sse2
-fftwf_codelet_n1bv_20_avx
-fftwf_codelet_n1bv_20_sse2
-fftwf_codelet_n1bv_25_avx
-fftwf_codelet_n1bv_25_sse2
-fftwf_codelet_n1bv_2_avx
-fftwf_codelet_n1bv_2_sse2
-fftwf_codelet_n1bv_32_avx
-fftwf_codelet_n1bv_32_sse2
-fftwf_codelet_n1bv_3_avx
-fftwf_codelet_n1bv_3_sse2
-fftwf_codelet_n1bv_4_avx
-fftwf_codelet_n1bv_4_sse2
-fftwf_codelet_n1bv_5_avx
-fftwf_codelet_n1bv_5_sse2
-fftwf_codelet_n1bv_64_avx
-fftwf_codelet_n1bv_64_sse2
-fftwf_codelet_n1bv_6_avx
-fftwf_codelet_n1bv_6_sse2
-fftwf_codelet_n1bv_7_avx
-fftwf_codelet_n1bv_7_sse2
-fftwf_codelet_n1bv_8_avx
-fftwf_codelet_n1bv_8_sse2
-fftwf_codelet_n1bv_9_avx
-fftwf_codelet_n1bv_9_sse2
-fftwf_codelet_n1fv_10_avx
-fftwf_codelet_n1fv_10_sse2
-fftwf_codelet_n1fv_11_avx
-fftwf_codelet_n1fv_11_sse2
-fftwf_codelet_n1fv_128_avx
-fftwf_codelet_n1fv_128_sse2
-fftwf_codelet_n1fv_12_avx
-fftwf_codelet_n1fv_12_sse2
-fftwf_codelet_n1fv_13_avx
-fftwf_codelet_n1fv_13_sse2
-fftwf_codelet_n1fv_14_avx
-fftwf_codelet_n1fv_14_sse2
-fftwf_codelet_n1fv_15_avx
-fftwf_codelet_n1fv_15_sse2
-fftwf_codelet_n1fv_16_avx
-fftwf_codelet_n1fv_16_sse2
-fftwf_codelet_n1fv_20_avx
-fftwf_codelet_n1fv_20_sse2
-fftwf_codelet_n1fv_25_avx
-fftwf_codelet_n1fv_25_sse2
-fftwf_codelet_n1fv_2_avx
-fftwf_codelet_n1fv_2_sse2
-fftwf_codelet_n1fv_32_avx
-fftwf_codelet_n1fv_32_sse2
-fftwf_codelet_n1fv_3_avx
-fftwf_codelet_n1fv_3_sse2
-fftwf_codelet_n1fv_4_avx
-fftwf_codelet_n1fv_4_sse2
-fftwf_codelet_n1fv_5_avx
-fftwf_codelet_n1fv_5_sse2
-fftwf_codelet_n1fv_64_avx
-fftwf_codelet_n1fv_64_sse2
-fftwf_codelet_n1fv_6_avx
-fftwf_codelet_n1fv_6_sse2
-fftwf_codelet_n1fv_7_avx
-fftwf_codelet_n1fv_7_sse2
-fftwf_codelet_n1fv_8_avx
-fftwf_codelet_n1fv_8_sse2
-fftwf_codelet_n1fv_9_avx
-fftwf_codelet_n1fv_9_sse2
-fftwf_codelet_n2bv_10_avx
-fftwf_codelet_n2bv_10_sse2
-fftwf_codelet_n2bv_12_avx
-fftwf_codelet_n2bv_12_sse2
-fftwf_codelet_n2bv_14_avx
-fftwf_codelet_n2bv_14_sse2
-fftwf_codelet_n2bv_16_avx
-fftwf_codelet_n2bv_16_sse2
-fftwf_codelet_n2bv_20_avx
-fftwf_codelet_n2bv_20_sse2
-fftwf_codelet_n2bv_2_avx
-fftwf_codelet_n2bv_2_sse2
-fftwf_codelet_n2bv_32_avx
-fftwf_codelet_n2bv_32_sse2
-fftwf_codelet_n2bv_4_avx
-fftwf_codelet_n2bv_4_sse2
-fftwf_codelet_n2bv_64_avx
-fftwf_codelet_n2bv_64_sse2
-fftwf_codelet_n2bv_6_avx
-fftwf_codelet_n2bv_6_sse2
-fftwf_codelet_n2bv_8_avx
-fftwf_codelet_n2bv_8_sse2
-fftwf_codelet_n2fv_10_avx
-fftwf_codelet_n2fv_10_sse2
-fftwf_codelet_n2fv_12_avx
-fftwf_codelet_n2fv_12_sse2
-fftwf_codelet_n2fv_14_avx
-fftwf_codelet_n2fv_14_sse2
-fftwf_codelet_n2fv_16_avx
-fftwf_codelet_n2fv_16_sse2
-fftwf_codelet_n2fv_20_avx
-fftwf_codelet_n2fv_20_sse2
-fftwf_codelet_n2fv_2_avx
-fftwf_codelet_n2fv_2_sse2
-fftwf_codelet_n2fv_32_avx
-fftwf_codelet_n2fv_32_sse2
-fftwf_codelet_n2fv_4_avx
-fftwf_codelet_n2fv_4_sse2
-fftwf_codelet_n2fv_64_avx
-fftwf_codelet_n2fv_64_sse2
-fftwf_codelet_n2fv_6_avx
-fftwf_codelet_n2fv_6_sse2
-fftwf_codelet_n2fv_8_avx
-fftwf_codelet_n2fv_8_sse2
-fftwf_codelet_n2sv_16_avx
-fftwf_codelet_n2sv_16_sse2
-fftwf_codelet_n2sv_32_avx
-fftwf_codelet_n2sv_32_sse2
-fftwf_codelet_n2sv_4_avx
-fftwf_codelet_n2sv_4_sse2
-fftwf_codelet_n2sv_64_avx
-fftwf_codelet_n2sv_64_sse2
-fftwf_codelet_n2sv_8_avx
-fftwf_codelet_n2sv_8_sse2
-fftwf_codelet_q1_2
-fftwf_codelet_q1_3
-fftwf_codelet_q1_4
-fftwf_codelet_q1_5
-fftwf_codelet_q1_6
-fftwf_codelet_q1_8
-fftwf_codelet_q1bv_2_avx
-fftwf_codelet_q1bv_2_sse2
-fftwf_codelet_q1bv_4_avx
-fftwf_codelet_q1bv_4_sse2
-fftwf_codelet_q1bv_5_avx
-fftwf_codelet_q1bv_5_sse2
-fftwf_codelet_q1bv_8_avx
-fftwf_codelet_q1bv_8_sse2
-fftwf_codelet_q1fv_2_avx
-fftwf_codelet_q1fv_2_sse2
-fftwf_codelet_q1fv_4_avx
-fftwf_codelet_q1fv_4_sse2
-fftwf_codelet_q1fv_5_avx
-fftwf_codelet_q1fv_5_sse2
-fftwf_codelet_q1fv_8_avx
-fftwf_codelet_q1fv_8_sse2
-fftwf_codelet_r2cbIII_10
-fftwf_codelet_r2cbIII_12
-fftwf_codelet_r2cbIII_15
-fftwf_codelet_r2cbIII_16
-fftwf_codelet_r2cbIII_2
-fftwf_codelet_r2cbIII_20
-fftwf_codelet_r2cbIII_25
-fftwf_codelet_r2cbIII_3
-fftwf_codelet_r2cbIII_32
-fftwf_codelet_r2cbIII_4
-fftwf_codelet_r2cbIII_5
-fftwf_codelet_r2cbIII_6
-fftwf_codelet_r2cbIII_64
-fftwf_codelet_r2cbIII_7
-fftwf_codelet_r2cbIII_8
-fftwf_codelet_r2cbIII_9
-fftwf_codelet_r2cb_10
-fftwf_codelet_r2cb_11
-fftwf_codelet_r2cb_12
-fftwf_codelet_r2cb_128
-fftwf_codelet_r2cb_13
-fftwf_codelet_r2cb_14
-fftwf_codelet_r2cb_15
-fftwf_codelet_r2cb_16
-fftwf_codelet_r2cb_2
-fftwf_codelet_r2cb_20
-fftwf_codelet_r2cb_25
-fftwf_codelet_r2cb_3
-fftwf_codelet_r2cb_32
-fftwf_codelet_r2cb_4
-fftwf_codelet_r2cb_5
-fftwf_codelet_r2cb_6
-fftwf_codelet_r2cb_64
-fftwf_codelet_r2cb_7
-fftwf_codelet_r2cb_8
-fftwf_codelet_r2cb_9
-fftwf_codelet_r2cfII_10
-fftwf_codelet_r2cfII_12
-fftwf_codelet_r2cfII_15
-fftwf_codelet_r2cfII_16
-fftwf_codelet_r2cfII_2
-fftwf_codelet_r2cfII_20
-fftwf_codelet_r2cfII_25
-fftwf_codelet_r2cfII_3
-fftwf_codelet_r2cfII_32
-fftwf_codelet_r2cfII_4
-fftwf_codelet_r2cfII_5
-fftwf_codelet_r2cfII_6
-fftwf_codelet_r2cfII_64
-fftwf_codelet_r2cfII_7
-fftwf_codelet_r2cfII_8
-fftwf_codelet_r2cfII_9
-fftwf_codelet_r2cf_10
-fftwf_codelet_r2cf_11
-fftwf_codelet_r2cf_12
-fftwf_codelet_r2cf_128
-fftwf_codelet_r2cf_13
-fftwf_codelet_r2cf_14
-fftwf_codelet_r2cf_15
-fftwf_codelet_r2cf_16
-fftwf_codelet_r2cf_2
-fftwf_codelet_r2cf_20
-fftwf_codelet_r2cf_25
-fftwf_codelet_r2cf_3
-fftwf_codelet_r2cf_32
-fftwf_codelet_r2cf_4
-fftwf_codelet_r2cf_5
-fftwf_codelet_r2cf_6
-fftwf_codelet_r2cf_64
-fftwf_codelet_r2cf_7
-fftwf_codelet_r2cf_8
-fftwf_codelet_r2cf_9
-fftwf_codelet_t1_10
-fftwf_codelet_t1_12
-fftwf_codelet_t1_15
-fftwf_codelet_t1_16
-fftwf_codelet_t1_2
-fftwf_codelet_t1_20
-fftwf_codelet_t1_25
-fftwf_codelet_t1_3
-fftwf_codelet_t1_32
-fftwf_codelet_t1_4
-fftwf_codelet_t1_5
-fftwf_codelet_t1_6
-fftwf_codelet_t1_64
-fftwf_codelet_t1_7
-fftwf_codelet_t1_8
-fftwf_codelet_t1_9
-fftwf_codelet_t1buv_10_avx
-fftwf_codelet_t1buv_10_sse2
-fftwf_codelet_t1buv_2_avx
-fftwf_codelet_t1buv_2_sse2
-fftwf_codelet_t1buv_3_avx
-fftwf_codelet_t1buv_3_sse2
-fftwf_codelet_t1buv_4_avx
-fftwf_codelet_t1buv_4_sse2
-fftwf_codelet_t1buv_5_avx
-fftwf_codelet_t1buv_5_sse2
-fftwf_codelet_t1buv_6_avx
-fftwf_codelet_t1buv_6_sse2
-fftwf_codelet_t1buv_7_avx
-fftwf_codelet_t1buv_7_sse2
-fftwf_codelet_t1buv_8_avx
-fftwf_codelet_t1buv_8_sse2
-fftwf_codelet_t1buv_9_avx
-fftwf_codelet_t1buv_9_sse2
-fftwf_codelet_t1bv_10_avx
-fftwf_codelet_t1bv_10_sse2
-fftwf_codelet_t1bv_12_avx
-fftwf_codelet_t1bv_12_sse2
-fftwf_codelet_t1bv_15_avx
-fftwf_codelet_t1bv_15_sse2
-fftwf_codelet_t1bv_16_avx
-fftwf_codelet_t1bv_16_sse2
-fftwf_codelet_t1bv_20_avx
-fftwf_codelet_t1bv_20_sse2
-fftwf_codelet_t1bv_25_avx
-fftwf_codelet_t1bv_25_sse2
-fftwf_codelet_t1bv_2_avx
-fftwf_codelet_t1bv_2_sse2
-fftwf_codelet_t1bv_32_avx
-fftwf_codelet_t1bv_32_sse2
-fftwf_codelet_t1bv_3_avx
-fftwf_codelet_t1bv_3_sse2
-fftwf_codelet_t1bv_4_avx
-fftwf_codelet_t1bv_4_sse2
-fftwf_codelet_t1bv_5_avx
-fftwf_codelet_t1bv_5_sse2
-fftwf_codelet_t1bv_64_avx
-fftwf_codelet_t1bv_64_sse2
-fftwf_codelet_t1bv_6_avx
-fftwf_codelet_t1bv_6_sse2
-fftwf_codelet_t1bv_7_avx
-fftwf_codelet_t1bv_7_sse2
-fftwf_codelet_t1bv_8_avx
-fftwf_codelet_t1bv_8_sse2
-fftwf_codelet_t1bv_9_avx
-fftwf_codelet_t1bv_9_sse2
-fftwf_codelet_t1fuv_10_avx
-fftwf_codelet_t1fuv_10_sse2
-fftwf_codelet_t1fuv_2_avx
-fftwf_codelet_t1fuv_2_sse2
-fftwf_codelet_t1fuv_3_avx
-fftwf_codelet_t1fuv_3_sse2
-fftwf_codelet_t1fuv_4_avx
-fftwf_codelet_t1fuv_4_sse2
-fftwf_codelet_t1fuv_5_avx
-fftwf_codelet_t1fuv_5_sse2
-fftwf_codelet_t1fuv_6_avx
-fftwf_codelet_t1fuv_6_sse2
-fftwf_codelet_t1fuv_7_avx
-fftwf_codelet_t1fuv_7_sse2
-fftwf_codelet_t1fuv_8_avx
-fftwf_codelet_t1fuv_8_sse2
-fftwf_codelet_t1fuv_9_avx
-fftwf_codelet_t1fuv_9_sse2
-fftwf_codelet_t1fv_10_avx
-fftwf_codelet_t1fv_10_sse2
-fftwf_codelet_t1fv_12_avx
-fftwf_codelet_t1fv_12_sse2
-fftwf_codelet_t1fv_15_avx
-fftwf_codelet_t1fv_15_sse2
-fftwf_codelet_t1fv_16_avx
-fftwf_codelet_t1fv_16_sse2
-fftwf_codelet_t1fv_20_avx
-fftwf_codelet_t1fv_20_sse2
-fftwf_codelet_t1fv_25_avx
-fftwf_codelet_t1fv_25_sse2
-fftwf_codelet_t1fv_2_avx
-fftwf_codelet_t1fv_2_sse2
-fftwf_codelet_t1fv_32_avx
-fftwf_codelet_t1fv_32_sse2
-fftwf_codelet_t1fv_3_avx
-fftwf_codelet_t1fv_3_sse2
-fftwf_codelet_t1fv_4_avx
-fftwf_codelet_t1fv_4_sse2
-fftwf_codelet_t1fv_5_avx
-fftwf_codelet_t1fv_5_sse2
-fftwf_codelet_t1fv_64_avx
-fftwf_codelet_t1fv_64_sse2
-fftwf_codelet_t1fv_6_avx
-fftwf_codelet_t1fv_6_sse2
-fftwf_codelet_t1fv_7_avx
-fftwf_codelet_t1fv_7_sse2
-fftwf_codelet_t1fv_8_avx
-fftwf_codelet_t1fv_8_sse2
-fftwf_codelet_t1fv_9_avx
-fftwf_codelet_t1fv_9_sse2
-fftwf_codelet_t1sv_16_avx
-fftwf_codelet_t1sv_16_sse2
-fftwf_codelet_t1sv_2_avx
-fftwf_codelet_t1sv_2_sse2
-fftwf_codelet_t1sv_32_avx
-fftwf_codelet_t1sv_32_sse2
-fftwf_codelet_t1sv_4_avx
-fftwf_codelet_t1sv_4_sse2
-fftwf_codelet_t1sv_8_avx
-fftwf_codelet_t1sv_8_sse2
-fftwf_codelet_t2_10
-fftwf_codelet_t2_16
-fftwf_codelet_t2_20
-fftwf_codelet_t2_25
-fftwf_codelet_t2_32
-fftwf_codelet_t2_4
-fftwf_codelet_t2_5
-fftwf_codelet_t2_64
-fftwf_codelet_t2_8
-fftwf_codelet_t2bv_10_avx
-fftwf_codelet_t2bv_10_sse2
-fftwf_codelet_t2bv_16_avx
-fftwf_codelet_t2bv_16_sse2
-fftwf_codelet_t2bv_20_avx
-fftwf_codelet_t2bv_20_sse2
-fftwf_codelet_t2bv_25_avx
-fftwf_codelet_t2bv_25_sse2
-fftwf_codelet_t2bv_2_avx
-fftwf_codelet_t2bv_2_sse2
-fftwf_codelet_t2bv_32_avx
-fftwf_codelet_t2bv_32_sse2
-fftwf_codelet_t2bv_4_avx
-fftwf_codelet_t2bv_4_sse2
-fftwf_codelet_t2bv_5_avx
-fftwf_codelet_t2bv_5_sse2
-fftwf_codelet_t2bv_64_avx
-fftwf_codelet_t2bv_64_sse2
-fftwf_codelet_t2bv_8_avx
-fftwf_codelet_t2bv_8_sse2
-fftwf_codelet_t2fv_10_avx
-fftwf_codelet_t2fv_10_sse2
-fftwf_codelet_t2fv_16_avx
-fftwf_codelet_t2fv_16_sse2
-fftwf_codelet_t2fv_20_avx
-fftwf_codelet_t2fv_20_sse2
-fftwf_codelet_t2fv_25_avx
-fftwf_codelet_t2fv_25_sse2
-fftwf_codelet_t2fv_2_avx
-fftwf_codelet_t2fv_2_sse2
-fftwf_codelet_t2fv_32_avx
-fftwf_codelet_t2fv_32_sse2
-fftwf_codelet_t2fv_4_avx
-fftwf_codelet_t2fv_4_sse2
-fftwf_codelet_t2fv_5_avx
-fftwf_codelet_t2fv_5_sse2
-fftwf_codelet_t2fv_64_avx
-fftwf_codelet_t2fv_64_sse2
-fftwf_codelet_t2fv_8_avx
-fftwf_codelet_t2fv_8_sse2
-fftwf_codelet_t2sv_16_avx
-fftwf_codelet_t2sv_16_sse2
-fftwf_codelet_t2sv_32_avx
-fftwf_codelet_t2sv_32_sse2
-fftwf_codelet_t2sv_4_avx
-fftwf_codelet_t2sv_4_sse2
-fftwf_codelet_t2sv_8_avx
-fftwf_codelet_t2sv_8_sse2
-fftwf_codelet_t3bv_10_avx
-fftwf_codelet_t3bv_10_sse2
-fftwf_codelet_t3bv_16_avx
-fftwf_codelet_t3bv_16_sse2
-fftwf_codelet_t3bv_20_avx
-fftwf_codelet_t3bv_20_sse2
-fftwf_codelet_t3bv_25_avx
-fftwf_codelet_t3bv_25_sse2
-fftwf_codelet_t3bv_32_avx
-fftwf_codelet_t3bv_32_sse2
-fftwf_codelet_t3bv_4_avx
-fftwf_codelet_t3bv_4_sse2
-fftwf_codelet_t3bv_5_avx
-fftwf_codelet_t3bv_5_sse2
-fftwf_codelet_t3bv_8_avx
-fftwf_codelet_t3bv_8_sse2
-fftwf_codelet_t3fv_10_avx
-fftwf_codelet_t3fv_10_sse2
-fftwf_codelet_t3fv_16_avx
-fftwf_codelet_t3fv_16_sse2
-fftwf_codelet_t3fv_20_avx
-fftwf_codelet_t3fv_20_sse2
-fftwf_codelet_t3fv_25_avx
-fftwf_codelet_t3fv_25_sse2
-fftwf_codelet_t3fv_32_avx
-fftwf_codelet_t3fv_32_sse2
-fftwf_codelet_t3fv_4_avx
-fftwf_codelet_t3fv_4_sse2
-fftwf_codelet_t3fv_5_avx
-fftwf_codelet_t3fv_5_sse2
-fftwf_codelet_t3fv_8_avx
-fftwf_codelet_t3fv_8_sse2
-fftwf_compute_tilesz
-fftwf_configure_planner
-fftwf_cost
-fftwf_cpy1d
-fftwf_cpy2d
-fftwf_cpy2d_ci
-fftwf_cpy2d_co
-fftwf_cpy2d_pair
-fftwf_cpy2d_pair_ci
-fftwf_cpy2d_pair_co
-fftwf_cpy2d_tiled
-fftwf_cpy2d_tiledbuf
-fftwf_ct_applicable
-fftwf_ct_generic_register
-fftwf_ct_genericbuf_register
-fftwf_ct_uglyp
-fftwf_destroy_plan
-fftwf_dft_bluestein_register
-fftwf_dft_buffered_register
-fftwf_dft_conf_standard
-fftwf_dft_generic_register
-fftwf_dft_indirect_register
-fftwf_dft_indirect_transpose_register
-fftwf_dft_nop_register
-fftwf_dft_r2hc_register
-fftwf_dft_rader_register
-fftwf_dft_rank_geq2_register
-fftwf_dft_solve
-fftwf_dft_thr_vrank_geq1_register
-fftwf_dft_vrank_geq1_register
-fftwf_dft_zerotens
-fftwf_dht_r2hc_register
-fftwf_dht_rader_register
-fftwf_dimcmp
-fftwf_elapsed_since
-fftwf_estimate_cost
-fftwf_execute
-fftwf_execute_dft
-fftwf_execute_dft_c2r
-fftwf_execute_dft_r2c
-fftwf_execute_r2r
-fftwf_execute_split_dft
-fftwf_execute_split_dft_c2r
-fftwf_execute_split_dft_r2c
-fftwf_export_wisdom
-fftwf_export_wisdom_to_file
-fftwf_export_wisdom_to_filename
-fftwf_export_wisdom_to_string
-fftwf_extract_reim
-fftwf_factors_into
-fftwf_factors_into_small_primes
-fftwf_find_generator
-fftwf_first_divisor
-fftwf_flops
-fftwf_forget_wisdom
-fftwf_fprint_plan
-fftwf_free
-fftwf_get_crude_time
-fftwf_guru64_kosherp
-fftwf_guru_kosherp
-fftwf_hash
-fftwf_have_simd_avx
-fftwf_have_simd_sse2
-fftwf_hc2c_applicable
-fftwf_hc2hc_applicable
-fftwf_hc2hc_generic_register
-fftwf_iabs
-fftwf_iestimate_cost
-fftwf_ifree
-fftwf_ifree0
-fftwf_imax
-fftwf_imin
-fftwf_import_system_wisdom
-fftwf_import_wisdom
-fftwf_import_wisdom_from_file
-fftwf_import_wisdom_from_filename
-fftwf_import_wisdom_from_string
-fftwf_init_threads
-fftwf_is_prime
-fftwf_isqrt
-fftwf_ithreads_init
-fftwf_join_taint
-fftwf_kdft_dif_register
-fftwf_kdft_difsq_register
-fftwf_kdft_dit_register
-fftwf_kdft_register
-fftwf_kernel_free
-fftwf_kernel_malloc
-fftwf_khc2c_register
-fftwf_khc2hc_register
-fftwf_kr2c_register
-fftwf_kr2r_register
-fftwf_malloc
-fftwf_malloc_plain
-fftwf_many_kosherp
-fftwf_map_r2r_kind
-fftwf_mapflags
-fftwf_md5INT
-fftwf_md5begin
-fftwf_md5end
-fftwf_md5int
-fftwf_md5putb
-fftwf_md5putc
-fftwf_md5puts
-fftwf_md5unsigned
-fftwf_measure_execution_time
-fftwf_mkapiplan
-fftwf_mkplan
-fftwf_mkplan_d
-fftwf_mkplan_dft
-fftwf_mkplan_dftw
-fftwf_mkplan_f_d
-fftwf_mkplan_hc2c
-fftwf_mkplan_hc2hc
-fftwf_mkplan_rdft
-fftwf_mkplan_rdft2
-fftwf_mkplanner
-fftwf_mkprinter
-fftwf_mkprinter_cnt
-fftwf_mkprinter_file
-fftwf_mkprinter_str
-fftwf_mkproblem
-fftwf_mkproblem_dft
-fftwf_mkproblem_dft_d
-fftwf_mkproblem_rdft
-fftwf_mkproblem_rdft2
-fftwf_mkproblem_rdft2_d
-fftwf_mkproblem_rdft2_d_3pointers
-fftwf_mkproblem_rdft_0_d
-fftwf_mkproblem_rdft_1
-fftwf_mkproblem_rdft_1_d
-fftwf_mkproblem_rdft_d
-fftwf_mkproblem_unsolvable
-fftwf_mkscanner
-fftwf_mksolver
-fftwf_mksolver_ct
-fftwf_mksolver_ct_threads
-fftwf_mksolver_dft_direct
-fftwf_mksolver_dft_directbuf
-fftwf_mksolver_hc2c
-fftwf_mksolver_hc2hc
-fftwf_mksolver_hc2hc_threads
-fftwf_mksolver_rdft2_direct
-fftwf_mksolver_rdft_r2c_direct
-fftwf_mksolver_rdft_r2c_directbuf
-fftwf_mksolver_rdft_r2r_direct
-fftwf_mkstride
-fftwf_mktensor
-fftwf_mktensor_0d
-fftwf_mktensor_1d
-fftwf_mktensor_2d
-fftwf_mktensor_3d
-fftwf_mktensor_4d
-fftwf_mktensor_5d
-fftwf_mktensor_iodims
-fftwf_mktensor_iodims64
-fftwf_mktensor_rowmajor
-fftwf_mktriggen
-fftwf_modulo
-fftwf_nbuf
-fftwf_nbuf_redundant
-fftwf_next_prime
-fftwf_null_awake
-fftwf_ops_add
-fftwf_ops_add2
-fftwf_ops_cpy
-fftwf_ops_madd
-fftwf_ops_madd2
-fftwf_ops_other
-fftwf_ops_zero
-fftwf_pickdim
-fftwf_plan_awake
-fftwf_plan_destroy_internal
-fftwf_plan_dft
-fftwf_plan_dft_1d
-fftwf_plan_dft_2d
-fftwf_plan_dft_3d
-fftwf_plan_dft_c2r
-fftwf_plan_dft_c2r_1d
-fftwf_plan_dft_c2r_2d
-fftwf_plan_dft_c2r_3d
-fftwf_plan_dft_r2c
-fftwf_plan_dft_r2c_1d
-fftwf_plan_dft_r2c_2d
-fftwf_plan_dft_r2c_3d
-fftwf_plan_guru64_dft
-fftwf_plan_guru64_dft_c2r
-fftwf_plan_guru64_dft_r2c
-fftwf_plan_guru64_r2r
-fftwf_plan_guru64_split_dft
-fftwf_plan_guru64_split_dft_c2r
-fftwf_plan_guru64_split_dft_r2c
-fftwf_plan_guru_dft
-fftwf_plan_guru_dft_c2r
-fftwf_plan_guru_dft_r2c
-fftwf_plan_guru_r2r
-fftwf_plan_guru_split_dft
-fftwf_plan_guru_split_dft_c2r
-fftwf_plan_guru_split_dft_r2c
-fftwf_plan_many_dft
-fftwf_plan_many_dft_c2r
-fftwf_plan_many_dft_r2c
-fftwf_plan_many_r2r
-fftwf_plan_null_destroy
-fftwf_plan_r2r
-fftwf_plan_r2r_1d
-fftwf_plan_r2r_2d
-fftwf_plan_r2r_3d
-fftwf_plan_with_nthreads
-fftwf_planner_destroy
-fftwf_power_mod
-fftwf_print_plan
-fftwf_printer_destroy
-fftwf_problem_destroy
-fftwf_rader_tl_delete
-fftwf_rader_tl_find
-fftwf_rader_tl_insert
-fftwf_rdft2_buffered_register
-fftwf_rdft2_complex_n
-fftwf_rdft2_inplace_strides
-fftwf_rdft2_nop_register
-fftwf_rdft2_pad
-fftwf_rdft2_rank0_register
-fftwf_rdft2_rank_geq2_register
-fftwf_rdft2_rdft_register
-fftwf_rdft2_solve
-fftwf_rdft2_strides
-fftwf_rdft2_tensor_max_index
-fftwf_rdft2_thr_vrank_geq1_register
-fftwf_rdft2_vrank_geq1_register
-fftwf_rdft_buffered_register
-fftwf_rdft_conf_standard
-fftwf_rdft_dht_register
-fftwf_rdft_generic_register
-fftwf_rdft_indirect_register
-fftwf_rdft_kind_str
-fftwf_rdft_nop_register
-fftwf_rdft_rank0_register
-fftwf_rdft_rank_geq2_register
-fftwf_rdft_solve
-fftwf_rdft_thr_vrank_geq1_register
-fftwf_rdft_vrank3_transpose_register
-fftwf_rdft_vrank_geq1_register
-fftwf_rdft_zerotens
-fftwf_redft00e_r2hc_pad_register
-fftwf_regsolver_ct_directw
-fftwf_regsolver_ct_directwsq
-fftwf_regsolver_hc2c_direct
-fftwf_regsolver_hc2hc_direct
-fftwf_reodft00e_splitradix_register
-fftwf_reodft010e_r2hc_register
-fftwf_reodft11e_r2hc_odd_register
-fftwf_reodft11e_radix2_r2hc_register
-fftwf_reodft_conf_standard
-fftwf_rodft00e_r2hc_pad_register
-fftwf_safe_mulmod
-fftwf_scanner_destroy
-fftwf_set_timelimit
-fftwf_solver_destroy
-fftwf_solver_register
-fftwf_solver_use
-fftwf_solvtab_exec
-fftwf_spawn_loop
-fftwf_sprint_plan
-fftwf_stride_destroy
-fftwf_taint
-fftwf_tensor_append
-fftwf_tensor_compress
-fftwf_tensor_compress_contiguous
-fftwf_tensor_copy
-fftwf_tensor_copy_except
-fftwf_tensor_copy_inplace
-fftwf_tensor_copy_sub
-fftwf_tensor_destroy
-fftwf_tensor_destroy2
-fftwf_tensor_destroy4
-fftwf_tensor_equal
-fftwf_tensor_inplace_locations
-fftwf_tensor_inplace_strides
-fftwf_tensor_inplace_strides2
-fftwf_tensor_kosherp
-fftwf_tensor_max_index
-fftwf_tensor_md5
-fftwf_tensor_min_istride
-fftwf_tensor_min_ostride
-fftwf_tensor_min_stride
-fftwf_tensor_print
-fftwf_tensor_split
-fftwf_tensor_strides_decrease
-fftwf_tensor_sz
-fftwf_tensor_tornk1
-fftwf_the_planner
-fftwf_threads_cleanup
-fftwf_threads_conf_standard
-fftwf_tile2d
-fftwf_toobig
-fftwf_transpose
-fftwf_transpose_tiled
-fftwf_transpose_tiledbuf
-fftwf_triggen_destroy
-fftwf_twiddle_awake
-fftwf_twiddle_length
-sfftw_cleanup_
-sfftw_cleanup__
-sfftw_cleanup_threads_
-sfftw_cleanup_threads__
-sfftw_cost_
-sfftw_cost__
-sfftw_destroy_plan_
-sfftw_destroy_plan__
-sfftw_estimate_cost_
-sfftw_estimate_cost__
-sfftw_execute_
-sfftw_execute__
-sfftw_execute_dft_
-sfftw_execute_dft__
-sfftw_execute_dft_c2r_
-sfftw_execute_dft_c2r__
-sfftw_execute_dft_r2c_
-sfftw_execute_dft_r2c__
-sfftw_execute_r2r_
-sfftw_execute_r2r__
-sfftw_execute_split_dft_
-sfftw_execute_split_dft__
-sfftw_execute_split_dft_c2r_
-sfftw_execute_split_dft_c2r__
-sfftw_execute_split_dft_r2c_
-sfftw_execute_split_dft_r2c__
-sfftw_export_wisdom_
-sfftw_export_wisdom__
-sfftw_flops_
-sfftw_flops__
-sfftw_forget_wisdom_
-sfftw_forget_wisdom__
-sfftw_import_system_wisdom_
-sfftw_import_system_wisdom__
-sfftw_import_wisdom_
-sfftw_import_wisdom__
-sfftw_init_threads_
-sfftw_init_threads__
-sfftw_plan_dft_
-sfftw_plan_dft_1d_
-sfftw_plan_dft_1d__
-sfftw_plan_dft_2d_
-sfftw_plan_dft_2d__
-sfftw_plan_dft_3d_
-sfftw_plan_dft_3d__
-sfftw_plan_dft__
-sfftw_plan_dft_c2r_
-sfftw_plan_dft_c2r_1d_
-sfftw_plan_dft_c2r_1d__
-sfftw_plan_dft_c2r_2d_
-sfftw_plan_dft_c2r_2d__
-sfftw_plan_dft_c2r_3d_
-sfftw_plan_dft_c2r_3d__
-sfftw_plan_dft_c2r__
-sfftw_plan_dft_r2c_
-sfftw_plan_dft_r2c_1d_
-sfftw_plan_dft_r2c_1d__
-sfftw_plan_dft_r2c_2d_
-sfftw_plan_dft_r2c_2d__
-sfftw_plan_dft_r2c_3d_
-sfftw_plan_dft_r2c_3d__
-sfftw_plan_dft_r2c__
-sfftw_plan_guru_dft_
-sfftw_plan_guru_dft__
-sfftw_plan_guru_dft_c2r_
-sfftw_plan_guru_dft_c2r__
-sfftw_plan_guru_dft_r2c_
-sfftw_plan_guru_dft_r2c__
-sfftw_plan_guru_r2r_
-sfftw_plan_guru_r2r__
-sfftw_plan_guru_split_dft_
-sfftw_plan_guru_split_dft__
-sfftw_plan_guru_split_dft_c2r_
-sfftw_plan_guru_split_dft_c2r__
-sfftw_plan_guru_split_dft_r2c_
-sfftw_plan_guru_split_dft_r2c__
-sfftw_plan_many_dft_
-sfftw_plan_many_dft__
-sfftw_plan_many_dft_c2r_
-sfftw_plan_many_dft_c2r__
-sfftw_plan_many_dft_r2c_
-sfftw_plan_many_dft_r2c__
-sfftw_plan_many_r2r_
-sfftw_plan_many_r2r__
-sfftw_plan_r2r_
-sfftw_plan_r2r_1d_
-sfftw_plan_r2r_1d__
-sfftw_plan_r2r_2d_
-sfftw_plan_r2r_2d__
-sfftw_plan_r2r_3d_
-sfftw_plan_r2r_3d__
-sfftw_plan_r2r__
-sfftw_plan_with_nthreads_
-sfftw_plan_with_nthreads__
-sfftw_print_plan_
-sfftw_print_plan__
-sfftw_set_timelimit_
-sfftw_set_timelimit__
diff --git a/external/fftw-3.3.4/64/libfftw3f-3.dll b/external/fftw-3.3.4/64/libfftw3f-3.dll
deleted file mode 100644
index 3244b4f..0000000
Binary files a/external/fftw-3.3.4/64/libfftw3f-3.dll and /dev/null differ
diff --git a/external/fftw-3.3.4/64/libfftw3f-3.exp b/external/fftw-3.3.4/64/libfftw3f-3.exp
deleted file mode 100644
index c300e32..0000000
Binary files a/external/fftw-3.3.4/64/libfftw3f-3.exp and /dev/null differ
diff --git a/external/fftw-3.3.4/64/libfftw3f-3.lib b/external/fftw-3.3.4/64/libfftw3f-3.lib
deleted file mode 100644
index 0940a86..0000000
Binary files a/external/fftw-3.3.4/64/libfftw3f-3.lib and /dev/null differ
diff --git a/external/fftw-3.3.4/fftw3.h b/external/fftw-3.3.4/fftw3.h
deleted file mode 100644
index 4326eae..0000000
--- a/external/fftw-3.3.4/fftw3.h
+++ /dev/null
@@ -1,414 +0,0 @@
-/*
- * Copyright (c) 2003, 2007-14 Matteo Frigo
- * Copyright (c) 2003, 2007-14 Massachusetts Institute of Technology
- *
- * The following statement of license applies *only* to this header file,
- * and *not* to the other files distributed with FFTW or derived therefrom:
- * 
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- *
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- *
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
- */
-
-/***************************** NOTE TO USERS *********************************
- *
- *                 THIS IS A HEADER FILE, NOT A MANUAL
- *
- *    If you want to know how to use FFTW, please read the manual,
- *    online at http://www.fftw.org/doc/ and also included with FFTW.
- *    For a quick start, see the manual's tutorial section.
- *
- *   (Reading header files to learn how to use a library is a habit
- *    stemming from code lacking a proper manual.  Arguably, it's a
- *    *bad* habit in most cases, because header files can contain
- *    interfaces that are not part of the public, stable API.)
- *
- ****************************************************************************/
-
-#ifndef FFTW3_H
-#define FFTW3_H
-
-#include <stdio.h>
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif /* __cplusplus */
-
-/* If <complex.h> is included, use the C99 complex type.  Otherwise
-   define a type bit-compatible with C99 complex */
-#if !defined(FFTW_NO_Complex) && defined(_Complex_I) && defined(complex) && defined(I)
-#  define FFTW_DEFINE_COMPLEX(R, C) typedef R _Complex C
-#else
-#  define FFTW_DEFINE_COMPLEX(R, C) typedef R C[2]
-#endif
-
-#define FFTW_CONCAT(prefix, name) prefix ## name
-#define FFTW_MANGLE_DOUBLE(name) FFTW_CONCAT(fftw_, name)
-#define FFTW_MANGLE_FLOAT(name) FFTW_CONCAT(fftwf_, name)
-#define FFTW_MANGLE_LONG_DOUBLE(name) FFTW_CONCAT(fftwl_, name)
-#define FFTW_MANGLE_QUAD(name) FFTW_CONCAT(fftwq_, name)
-
-/* IMPORTANT: for Windows compilers, you should add a line
-*/
-#define FFTW_DLL
-/*
-   here and in kernel/ifftw.h if you are compiling/using FFTW as a
-   DLL, in order to do the proper importing/exporting, or
-   alternatively compile with -DFFTW_DLL or the equivalent
-   command-line flag.  This is not necessary under MinGW/Cygwin, where
-   libtool does the imports/exports automatically. */
-#if defined(FFTW_DLL) && (defined(_WIN32) || defined(__WIN32__))
-   /* annoying Windows syntax for shared-library declarations */
-#  if defined(COMPILING_FFTW) /* defined in api.h when compiling FFTW */
-#    define FFTW_EXTERN extern __declspec(dllexport) 
-#  else /* user is calling FFTW; import symbol */
-#    define FFTW_EXTERN extern __declspec(dllimport) 
-#  endif
-#else
-#  define FFTW_EXTERN extern
-#endif
-
-enum fftw_r2r_kind_do_not_use_me {
-     FFTW_R2HC=0, FFTW_HC2R=1, FFTW_DHT=2,
-     FFTW_REDFT00=3, FFTW_REDFT01=4, FFTW_REDFT10=5, FFTW_REDFT11=6,
-     FFTW_RODFT00=7, FFTW_RODFT01=8, FFTW_RODFT10=9, FFTW_RODFT11=10
-};
-
-struct fftw_iodim_do_not_use_me {
-     int n;                     /* dimension size */
-     int is;			/* input stride */
-     int os;			/* output stride */
-};
-
-#include <stddef.h> /* for ptrdiff_t */
-struct fftw_iodim64_do_not_use_me {
-     ptrdiff_t n;                     /* dimension size */
-     ptrdiff_t is;			/* input stride */
-     ptrdiff_t os;			/* output stride */
-};
-
-typedef void (*fftw_write_char_func_do_not_use_me)(char c, void *);
-typedef int (*fftw_read_char_func_do_not_use_me)(void *);
-
-/*
-  huge second-order macro that defines prototypes for all API
-  functions.  We expand this macro for each supported precision
- 
-  X: name-mangling macro
-  R: real data type
-  C: complex data type
-*/
-
-#define FFTW_DEFINE_API(X, R, C)					   \
-									   \
-FFTW_DEFINE_COMPLEX(R, C);						   \
-									   \
-typedef struct X(plan_s) *X(plan);					   \
-									   \
-typedef struct fftw_iodim_do_not_use_me X(iodim);			   \
-typedef struct fftw_iodim64_do_not_use_me X(iodim64);			   \
-									   \
-typedef enum fftw_r2r_kind_do_not_use_me X(r2r_kind);			   \
-									   \
-typedef fftw_write_char_func_do_not_use_me X(write_char_func);		   \
-typedef fftw_read_char_func_do_not_use_me X(read_char_func);		   \
-									   \
-FFTW_EXTERN void X(execute)(const X(plan) p);				   \
-									   \
-FFTW_EXTERN X(plan) X(plan_dft)(int rank, const int *n,			   \
-		    C *in, C *out, int sign, unsigned flags);		   \
-									   \
-FFTW_EXTERN X(plan) X(plan_dft_1d)(int n, C *in, C *out, int sign,	   \
-		       unsigned flags);					   \
-FFTW_EXTERN X(plan) X(plan_dft_2d)(int n0, int n1,			   \
-		       C *in, C *out, int sign, unsigned flags);	   \
-FFTW_EXTERN X(plan) X(plan_dft_3d)(int n0, int n1, int n2,		   \
-		       C *in, C *out, int sign, unsigned flags);	   \
-									   \
-FFTW_EXTERN X(plan) X(plan_many_dft)(int rank, const int *n,		   \
-                         int howmany,					   \
-                         C *in, const int *inembed,			   \
-                         int istride, int idist,			   \
-                         C *out, const int *onembed,			   \
-                         int ostride, int odist,			   \
-                         int sign, unsigned flags);			   \
-									   \
-FFTW_EXTERN X(plan) X(plan_guru_dft)(int rank, const X(iodim) *dims,	   \
-			 int howmany_rank,				   \
-			 const X(iodim) *howmany_dims,			   \
-			 C *in, C *out,					   \
-			 int sign, unsigned flags);			   \
-FFTW_EXTERN X(plan) X(plan_guru_split_dft)(int rank, const X(iodim) *dims, \
-			 int howmany_rank,				   \
-			 const X(iodim) *howmany_dims,			   \
-			 R *ri, R *ii, R *ro, R *io,			   \
-			 unsigned flags);				   \
-									   \
-FFTW_EXTERN X(plan) X(plan_guru64_dft)(int rank,			   \
-                         const X(iodim64) *dims,			   \
-			 int howmany_rank,				   \
-			 const X(iodim64) *howmany_dims,		   \
-			 C *in, C *out,					   \
-			 int sign, unsigned flags);			   \
-FFTW_EXTERN X(plan) X(plan_guru64_split_dft)(int rank,			   \
-                         const X(iodim64) *dims,			   \
-			 int howmany_rank,				   \
-			 const X(iodim64) *howmany_dims,		   \
-			 R *ri, R *ii, R *ro, R *io,			   \
-			 unsigned flags);				   \
-									   \
-FFTW_EXTERN void X(execute_dft)(const X(plan) p, C *in, C *out);	   \
-FFTW_EXTERN void X(execute_split_dft)(const X(plan) p, R *ri, R *ii,	   \
-                                      R *ro, R *io);			   \
-									   \
-FFTW_EXTERN X(plan) X(plan_many_dft_r2c)(int rank, const int *n,	   \
-                             int howmany,				   \
-                             R *in, const int *inembed,			   \
-                             int istride, int idist,			   \
-                             C *out, const int *onembed,		   \
-                             int ostride, int odist,			   \
-                             unsigned flags);				   \
-									   \
-FFTW_EXTERN X(plan) X(plan_dft_r2c)(int rank, const int *n,		   \
-                        R *in, C *out, unsigned flags);			   \
-									   \
-FFTW_EXTERN X(plan) X(plan_dft_r2c_1d)(int n,R *in,C *out,unsigned flags); \
-FFTW_EXTERN X(plan) X(plan_dft_r2c_2d)(int n0, int n1,			   \
-			   R *in, C *out, unsigned flags);		   \
-FFTW_EXTERN X(plan) X(plan_dft_r2c_3d)(int n0, int n1,			   \
-			   int n2,					   \
-			   R *in, C *out, unsigned flags);		   \
-									   \
-									   \
-FFTW_EXTERN X(plan) X(plan_many_dft_c2r)(int rank, const int *n,	   \
-			     int howmany,				   \
-			     C *in, const int *inembed,			   \
-			     int istride, int idist,			   \
-			     R *out, const int *onembed,		   \
-			     int ostride, int odist,			   \
-			     unsigned flags);				   \
-									   \
-FFTW_EXTERN X(plan) X(plan_dft_c2r)(int rank, const int *n,		   \
-                        C *in, R *out, unsigned flags);			   \
-									   \
-FFTW_EXTERN X(plan) X(plan_dft_c2r_1d)(int n,C *in,R *out,unsigned flags); \
-FFTW_EXTERN X(plan) X(plan_dft_c2r_2d)(int n0, int n1,			   \
-			   C *in, R *out, unsigned flags);		   \
-FFTW_EXTERN X(plan) X(plan_dft_c2r_3d)(int n0, int n1,			   \
-			   int n2,					   \
-			   C *in, R *out, unsigned flags);		   \
-									   \
-FFTW_EXTERN X(plan) X(plan_guru_dft_r2c)(int rank, const X(iodim) *dims,   \
-			     int howmany_rank,				   \
-			     const X(iodim) *howmany_dims,		   \
-			     R *in, C *out,				   \
-			     unsigned flags);				   \
-FFTW_EXTERN X(plan) X(plan_guru_dft_c2r)(int rank, const X(iodim) *dims,   \
-			     int howmany_rank,				   \
-			     const X(iodim) *howmany_dims,		   \
-			     C *in, R *out,				   \
-			     unsigned flags);				   \
-									   \
-FFTW_EXTERN X(plan) X(plan_guru_split_dft_r2c)(				   \
-                             int rank, const X(iodim) *dims,		   \
-			     int howmany_rank,				   \
-			     const X(iodim) *howmany_dims,		   \
-			     R *in, R *ro, R *io,			   \
-			     unsigned flags);				   \
-FFTW_EXTERN X(plan) X(plan_guru_split_dft_c2r)(				   \
-                             int rank, const X(iodim) *dims,		   \
-			     int howmany_rank,				   \
-			     const X(iodim) *howmany_dims,		   \
-			     R *ri, R *ii, R *out,			   \
-			     unsigned flags);				   \
-									   \
-FFTW_EXTERN X(plan) X(plan_guru64_dft_r2c)(int rank,			   \
-                             const X(iodim64) *dims,			   \
-			     int howmany_rank,				   \
-			     const X(iodim64) *howmany_dims,		   \
-			     R *in, C *out,				   \
-			     unsigned flags);				   \
-FFTW_EXTERN X(plan) X(plan_guru64_dft_c2r)(int rank,			   \
-                             const X(iodim64) *dims,			   \
-			     int howmany_rank,				   \
-			     const X(iodim64) *howmany_dims,		   \
-			     C *in, R *out,				   \
-			     unsigned flags);				   \
-									   \
-FFTW_EXTERN X(plan) X(plan_guru64_split_dft_r2c)(			   \
-                             int rank, const X(iodim64) *dims,		   \
-			     int howmany_rank,				   \
-			     const X(iodim64) *howmany_dims,		   \
-			     R *in, R *ro, R *io,			   \
-			     unsigned flags);				   \
-FFTW_EXTERN X(plan) X(plan_guru64_split_dft_c2r)(			   \
-                             int rank, const X(iodim64) *dims,		   \
-			     int howmany_rank,				   \
-			     const X(iodim64) *howmany_dims,		   \
-			     R *ri, R *ii, R *out,			   \
-			     unsigned flags);				   \
-									   \
-FFTW_EXTERN void X(execute_dft_r2c)(const X(plan) p, R *in, C *out);	   \
-FFTW_EXTERN void X(execute_dft_c2r)(const X(plan) p, C *in, R *out);	   \
-									   \
-FFTW_EXTERN void X(execute_split_dft_r2c)(const X(plan) p,		   \
-                                          R *in, R *ro, R *io);		   \
-FFTW_EXTERN void X(execute_split_dft_c2r)(const X(plan) p,		   \
-                                          R *ri, R *ii, R *out);	   \
-									   \
-FFTW_EXTERN X(plan) X(plan_many_r2r)(int rank, const int *n,		   \
-                         int howmany,					   \
-                         R *in, const int *inembed,			   \
-                         int istride, int idist,			   \
-                         R *out, const int *onembed,			   \
-                         int ostride, int odist,			   \
-                         const X(r2r_kind) *kind, unsigned flags);	   \
-									   \
-FFTW_EXTERN X(plan) X(plan_r2r)(int rank, const int *n, R *in, R *out,	   \
-                    const X(r2r_kind) *kind, unsigned flags);		   \
-									   \
-FFTW_EXTERN X(plan) X(plan_r2r_1d)(int n, R *in, R *out,		   \
-                       X(r2r_kind) kind, unsigned flags);		   \
-FFTW_EXTERN X(plan) X(plan_r2r_2d)(int n0, int n1, R *in, R *out,	   \
-                       X(r2r_kind) kind0, X(r2r_kind) kind1,		   \
-                       unsigned flags);					   \
-FFTW_EXTERN X(plan) X(plan_r2r_3d)(int n0, int n1, int n2,		   \
-                       R *in, R *out, X(r2r_kind) kind0,		   \
-                       X(r2r_kind) kind1, X(r2r_kind) kind2,		   \
-                       unsigned flags);					   \
-									   \
-FFTW_EXTERN X(plan) X(plan_guru_r2r)(int rank, const X(iodim) *dims,	   \
-                         int howmany_rank,				   \
-                         const X(iodim) *howmany_dims,			   \
-                         R *in, R *out,					   \
-                         const X(r2r_kind) *kind, unsigned flags);	   \
-									   \
-FFTW_EXTERN X(plan) X(plan_guru64_r2r)(int rank, const X(iodim64) *dims,   \
-                         int howmany_rank,				   \
-                         const X(iodim64) *howmany_dims,		   \
-                         R *in, R *out,					   \
-                         const X(r2r_kind) *kind, unsigned flags);	   \
-									   \
-FFTW_EXTERN void X(execute_r2r)(const X(plan) p, R *in, R *out);	   \
-									   \
-FFTW_EXTERN void X(destroy_plan)(X(plan) p);				   \
-FFTW_EXTERN void X(forget_wisdom)(void);				   \
-FFTW_EXTERN void X(cleanup)(void);					   \
-									   \
-FFTW_EXTERN void X(set_timelimit)(double t);				   \
-									   \
-FFTW_EXTERN void X(plan_with_nthreads)(int nthreads);			   \
-FFTW_EXTERN int X(init_threads)(void);					   \
-FFTW_EXTERN void X(cleanup_threads)(void);				   \
-									   \
-FFTW_EXTERN int X(export_wisdom_to_filename)(const char *filename);	   \
-FFTW_EXTERN void X(export_wisdom_to_file)(FILE *output_file);		   \
-FFTW_EXTERN char *X(export_wisdom_to_string)(void);			   \
-FFTW_EXTERN void X(export_wisdom)(X(write_char_func) write_char,   	   \
-                                  void *data);				   \
-FFTW_EXTERN int X(import_system_wisdom)(void);				   \
-FFTW_EXTERN int X(import_wisdom_from_filename)(const char *filename);	   \
-FFTW_EXTERN int X(import_wisdom_from_file)(FILE *input_file);		   \
-FFTW_EXTERN int X(import_wisdom_from_string)(const char *input_string);	   \
-FFTW_EXTERN int X(import_wisdom)(X(read_char_func) read_char, void *data); \
-									   \
-FFTW_EXTERN void X(fprint_plan)(const X(plan) p, FILE *output_file);	   \
-FFTW_EXTERN void X(print_plan)(const X(plan) p);			   \
-FFTW_EXTERN char *X(sprint_plan)(const X(plan) p);			   \
-									   \
-FFTW_EXTERN void *X(malloc)(size_t n);					   \
-FFTW_EXTERN R *X(alloc_real)(size_t n);					   \
-FFTW_EXTERN C *X(alloc_complex)(size_t n);				   \
-FFTW_EXTERN void X(free)(void *p);					   \
-									   \
-FFTW_EXTERN void X(flops)(const X(plan) p,				   \
-                          double *add, double *mul, double *fmas);	   \
-FFTW_EXTERN double X(estimate_cost)(const X(plan) p);			   \
-FFTW_EXTERN double X(cost)(const X(plan) p);				   \
-									   \
-FFTW_EXTERN int X(alignment_of)(R *p);                                     \
-FFTW_EXTERN const char X(version)[];                                       \
-FFTW_EXTERN const char X(cc)[];						   \
-FFTW_EXTERN const char X(codelet_optim)[];
-
-
-/* end of FFTW_DEFINE_API macro */
-
-FFTW_DEFINE_API(FFTW_MANGLE_DOUBLE, double, fftw_complex)
-FFTW_DEFINE_API(FFTW_MANGLE_FLOAT, float, fftwf_complex)
-FFTW_DEFINE_API(FFTW_MANGLE_LONG_DOUBLE, long double, fftwl_complex)
-
-/* __float128 (quad precision) is a gcc extension on i386, x86_64, and ia64
-   for gcc >= 4.6 (compiled in FFTW with --enable-quad-precision) */
-#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) \
- && !(defined(__ICC) || defined(__INTEL_COMPILER)) \
- && (defined(__i386__) || defined(__x86_64__) || defined(__ia64__))
-#  if !defined(FFTW_NO_Complex) && defined(_Complex_I) && defined(complex) && defined(I)
-/* note: __float128 is a typedef, which is not supported with the _Complex
-         keyword in gcc, so instead we use this ugly __attribute__ version.
-         However, we can't simply pass the __attribute__ version to
-         FFTW_DEFINE_API because the __attribute__ confuses gcc in pointer
-         types.  Hence redefining FFTW_DEFINE_COMPLEX.  Ugh. */
-#    undef FFTW_DEFINE_COMPLEX
-#    define FFTW_DEFINE_COMPLEX(R, C) typedef _Complex float __attribute__((mode(TC))) C
-#  endif
-FFTW_DEFINE_API(FFTW_MANGLE_QUAD, __float128, fftwq_complex)
-#endif
-
-#define FFTW_FORWARD (-1)
-#define FFTW_BACKWARD (+1)
-
-#define FFTW_NO_TIMELIMIT (-1.0)
-
-/* documented flags */
-#define FFTW_MEASURE (0U)
-#define FFTW_DESTROY_INPUT (1U << 0)
-#define FFTW_UNALIGNED (1U << 1)
-#define FFTW_CONSERVE_MEMORY (1U << 2)
-#define FFTW_EXHAUSTIVE (1U << 3) /* NO_EXHAUSTIVE is default */
-#define FFTW_PRESERVE_INPUT (1U << 4) /* cancels FFTW_DESTROY_INPUT */
-#define FFTW_PATIENT (1U << 5) /* IMPATIENT is default */
-#define FFTW_ESTIMATE (1U << 6)
-#define FFTW_WISDOM_ONLY (1U << 21)
-
-/* undocumented beyond-guru flags */
-#define FFTW_ESTIMATE_PATIENT (1U << 7)
-#define FFTW_BELIEVE_PCOST (1U << 8)
-#define FFTW_NO_DFT_R2HC (1U << 9)
-#define FFTW_NO_NONTHREADED (1U << 10)
-#define FFTW_NO_BUFFERING (1U << 11)
-#define FFTW_NO_INDIRECT_OP (1U << 12)
-#define FFTW_ALLOW_LARGE_GENERIC (1U << 13) /* NO_LARGE_GENERIC is default */
-#define FFTW_NO_RANK_SPLITS (1U << 14)
-#define FFTW_NO_VRANK_SPLITS (1U << 15)
-#define FFTW_NO_VRECURSE (1U << 16)
-#define FFTW_NO_SIMD (1U << 17)
-#define FFTW_NO_SLOW (1U << 18)
-#define FFTW_NO_FIXED_RADIX_LARGE_N (1U << 19)
-#define FFTW_ALLOW_PRUNING (1U << 20)
-
-#ifdef __cplusplus
-}  /* extern "C" */
-#endif /* __cplusplus */
-
-#endif /* FFTW3_H */
diff --git a/src/process/ScopeVisualProcessor.cpp b/src/process/ScopeVisualProcessor.cpp
index 9815a77..e5d57fc 100644
--- a/src/process/ScopeVisualProcessor.cpp
+++ b/src/process/ScopeVisualProcessor.cpp
@@ -9,42 +9,19 @@ ScopeVisualProcessor::ScopeVisualProcessor(): outputBuffers("ScopeVisualProcesso
 	fft_ceil_ma = fft_ceil_maa = 0;
 	fft_floor_ma = fft_floor_maa = 0;
     maxScopeSamples = 1024;
-#if USE_FFTW3
-    fftw_plan = nullptr;
-#else
     fftPlan = nullptr;
-#endif
 }
 
 ScopeVisualProcessor::~ScopeVisualProcessor() {
-#if USE_FFTW3
-    if (fftw_plan) {
-        fftwf_destroy_plan(fftw_plan);
-    }
-    
-#else
     if (fftPlan) {
         fft_destroy_plan(fftPlan);
     }
-    
-#endif
 }
 
 
 void ScopeVisualProcessor::setup(int fftSize_in) {
     fftSize = fftSize_in;
     desiredInputSize = fftSize;
-
-#if USE_FFTW3
-   
-    fftInData.resize(fftSize);  
-    fftwOutput.resize(fftSize);
-
-    if (fftw_plan) {
-        fftwf_destroy_plan(fftw_plan);
-    }
-    fftw_plan = fftwf_plan_dft_r2c_1d(fftSize, fftInData.data(), fftwOutput.data(), FFTW_ESTIMATE);
-#else
  
     fftInData.resize(fftSize);
     fftOutput.resize(fftSize);
@@ -53,7 +30,6 @@ void ScopeVisualProcessor::setup(int fftSize_in) {
         fft_destroy_plan(fftPlan);
     }
     fftPlan = fft_create_plan(fftSize, fftInData.data(), fftOutput.data(), LIQUID_FFT_FORWARD, 0);
-#endif
 }
 
 void ScopeVisualProcessor::setScopeEnabled(bool scopeEnable) {
@@ -142,26 +118,6 @@ void ScopeVisualProcessor::process() {
         if (spectrumEnabled) {
             iMax = audioInputData->data.size();
 
-#if USE_FFTW3
-            if (audioInputData->channels==1) {
-                for (i = 0; i < fftSize; i++) {
-                    if (i < iMax) {
-                        fftInData[i] = audioInputData->data[i];
-                    } else {
-                        fftInData[i] = 0;
-                    }
-                }
-            } else if (audioInputData->channels==2) {
-                iMax = iMax/2;
-                for (i = 0; i < fftSize; i++) {
-                    if (i < iMax) {
-                        fftInData[i] = audioInputData->data[i] + audioInputData->data[iMax+i];
-                    } else {
-                        fftInData[i] = 0;
-                    }
-                }
-            }
-#else
             if (audioInputData->channels==1) {
                 for (i = 0; i < fftSize; i++) {
                     if (i < iMax) {
@@ -184,7 +140,6 @@ void ScopeVisualProcessor::process() {
                     }
                 }
             }
-#endif
             
             renderData = outputBuffers.getBuffer();
 
@@ -202,19 +157,6 @@ void ScopeVisualProcessor::process() {
                 fft_result_maa.resize((fftSize/2));
             }
 
-#if USE_FFTW3
-            fftwf_execute(fftw_plan);
-            
-            for (i = 0; i < (fftSize/2); i++) {
-                //cast result to double to prevent overflows / excessive precision losses in the following computations...
-                double a = (double) fftwOutput[i][0];
-                double b = (double) fftwOutput[i][1];
-
-                //computes norm = sqrt(a**2 + b**2)
-                //being actually floats cast into doubles, we are indeed overflow-free here.
-                fft_result[i] = sqrt(a*a + b*b);
-            }
-#else
             fft_execute(fftPlan);
             for (i = 0; i < (fftSize/2); i++) {
 
@@ -226,7 +168,6 @@ void ScopeVisualProcessor::process() {
                 //being actually floats cast into doubles, we are indeed overflow-free here.
                 fft_result[i] = sqrt(a*a + b*b);
             }
-#endif
             
             for (i = 0; i < (fftSize/2); i++) {
                 fft_result_ma[i] += (fft_result[i] - fft_result_ma[i]) * fft_average_rate;
diff --git a/src/process/ScopeVisualProcessor.h b/src/process/ScopeVisualProcessor.h
index c0a19aa..ed85354 100644
--- a/src/process/ScopeVisualProcessor.h
+++ b/src/process/ScopeVisualProcessor.h
@@ -4,10 +4,6 @@
 #include "AudioThread.h"
 #include "ScopePanel.h"
 
-#if USE_FFTW3
-#include "fftw3.h"
-#endif
-
 class ScopeRenderData: public ReferenceCounter {
 public:
 	std::vector<float> waveform_points;
@@ -36,15 +32,9 @@ protected:
     std::atomic_bool scopeEnabled;
     std::atomic_bool spectrumEnabled;
     
-#if USE_FFTW3
-    std::vector<float> fftInData;
-    std::vector<fftwf_complex> fftwOutput;
-    std::vector<fftwf_plan> fftw_plan;
-#else
     std::vector<liquid_float_complex> fftInData;
     std::vector<liquid_float_complex> fftOutput;
     fftplan fftPlan;
-#endif
     
     unsigned int fftSize;
     int desiredInputSize;
diff --git a/src/process/SpectrumVisualProcessor.cpp b/src/process/SpectrumVisualProcessor.cpp
index bb6ced9..0ec0ff2 100644
--- a/src/process/SpectrumVisualProcessor.cpp
+++ b/src/process/SpectrumVisualProcessor.cpp
@@ -9,19 +9,11 @@ SpectrumVisualProcessor::SpectrumVisualProcessor() : outputBuffers("SpectrumVisu
     resampler = nullptr;
     resamplerRatio = 0;
 
-#if USE_FFTW3
-    fftwInput = nullptr;
-    fftwOutput = nullptr;
-    fftInData = nullptr;
-    fftLastData = nullptr;
-    fftw_plan = nullptr;
-#else
     fftInput = nullptr;
     fftOutput = nullptr;
     fftInData = nullptr;
     fftLastData = nullptr;
     fftPlan = nullptr;
-#endif
     
     is_view.store(false);
     fftSize.store(0);
@@ -129,42 +121,6 @@ void SpectrumVisualProcessor::setup(unsigned int fftSize_in) {
     fftSizeInternal = fftSize_in * SPECTRUM_VZM;
     lastDataSize = 0;
 
-#if USE_FFTW3
-    int memSize = sizeof(fftwf_complex) * fftSizeInternal;
-    
-    if (fftwInput) {
-        free(fftwInput);
-    }
-    //fftwInput = (fftwf_complex*) fftwf_malloc(memSize);
-	fftwInput = (fftwf_complex*)malloc(memSize);
-    memset(fftwInput,0,memSize);
-
-    if (fftInData) {
-        free(fftInData);
-    }
-    //fftInData = (fftwf_complex*) fftwf_malloc(memSize);
-	fftInData = (fftwf_complex*)malloc(memSize);
-    memset(fftwInput,0,memSize);
-    
-    if (fftLastData) {
-        free(fftLastData);
-    }
-    //fftLastData = (fftwf_complex*) fftwf_malloc(memSize);
-	fftLastData = (fftwf_complex*)malloc(memSize);
-    memset(fftwInput,0,memSize);
-    
-    if (fftwOutput) {
-        free(fftwOutput);
-    }
-    //fftwOutput = (fftwf_complex*) fftwf_malloc(memSize);
-	fftwOutput = (fftwf_complex*)malloc(memSize);
-	memset(fftwInput,0,memSize);
-    
-    if (fftw_plan) {
-        fftwf_destroy_plan(fftw_plan);
-    }
-    fftw_plan = fftwf_plan_dft_1d(fftSizeInternal, fftwInput, fftwOutput, FFTW_FORWARD, FFTW_ESTIMATE);
-#else
     int memSize = sizeof(liquid_float_complex) * fftSizeInternal;
     
     if (fftInput) {
@@ -195,7 +151,6 @@ void SpectrumVisualProcessor::setup(unsigned int fftSize_in) {
         fft_destroy_plan(fftPlan);
     }
     fftPlan = fft_create_plan(fftSizeInternal, fftInput, fftOutput, LIQUID_FFT_FORWARD, 0);
-#endif
     
 }
 
@@ -385,85 +340,26 @@ void SpectrumVisualProcessor::process() {
             
             msresamp_crcf_execute(resampler, &shiftBuffer[0], desired_input_size, &resampleBuffer[0], &num_written);
             
-#if USE_FFTW3
-            if (num_written < fftSizeInternal) {
-                for (unsigned int i = 0; i < num_written; i++) {
-                    fftInData[i][0] = resampleBuffer[i].real;
-                    fftInData[i][1] = resampleBuffer[i].imag;
-                }
-                for (unsigned int i = num_written; i < fftSizeInternal; i++) {
-                    fftInData[i][0] = 0;
-                    fftInData[i][1] = 0;
-                }
-            } else {
-                for (unsigned int i = 0; i < fftSizeInternal; i++) {
-                    fftInData[i][0] = resampleBuffer[i].real;
-                    fftInData[i][1] = resampleBuffer[i].imag;
-                }
-            }
-#else
             if (num_written < fftSizeInternal) {
                 memcpy(fftInData, resampleBuffer.data(), num_written * sizeof(liquid_float_complex));
                 memset(&(fftInData[num_written]), 0, (fftSizeInternal-num_written) * sizeof(liquid_float_complex));
             } else {
                 memcpy(fftInData, resampleBuffer.data(), fftSizeInternal * sizeof(liquid_float_complex));
             }
-#endif
         } else {
             this->desiredInputSize.store(fftSizeInternal);
 
             num_written = data->size();
-#if USE_FFTW3
-            if (data->size() < fftSizeInternal) {
-                for (size_t i = 0, iMax = data->size(); i < iMax; i++) {
-                    fftInData[i][0] = (*data)[i].real;
-                    fftInData[i][1] = (*data)[i].imag;
-                }
-                for (size_t i = data->size(); i < fftSizeInternal; i++) {
-                    fftInData[i][0] = 0;
-                    fftInData[i][1] = 0;
-                }
-            } else {
-                for (unsigned int i = 0; i < fftSizeInternal; i++) {
-                    fftInData[i][0] = (*data)[i].real;
-                    fftInData[i][1] = (*data)[i].imag;
-                }
-            }
-#else
             if (data->size() < fftSizeInternal) {
                 memcpy(fftInData, data->data(), data->size() * sizeof(liquid_float_complex));
                 memset(&fftInData[data->size()], 0, (fftSizeInternal - data->size()) * sizeof(liquid_float_complex));
             } else {
                 memcpy(fftInData, data->data(), fftSizeInternal * sizeof(liquid_float_complex));
             }
-#endif
         }
         
         bool execute = false;
 
-#if USE_FFTW3
-        if (num_written >= fftSizeInternal) {
-            execute = true;
-            memcpy(fftwInput, fftInData, fftSizeInternal * sizeof(fftwf_complex));
-            memcpy(fftLastData, fftwInput, fftSizeInternal * sizeof(fftwf_complex));
-            
-        } else {
-            if (lastDataSize + num_written < fftSizeInternal) { // priming
-                unsigned int num_copy = fftSizeInternal - lastDataSize;
-                if (num_written > num_copy) {
-                    num_copy = num_written;
-                }
-                memcpy(fftLastData, fftInData, num_copy * sizeof(fftwf_complex));
-                lastDataSize += num_copy;
-            } else {
-                unsigned int num_last = (fftSizeInternal - num_written);
-                memcpy(fftwInput, fftLastData + (lastDataSize - num_last), num_last * sizeof(fftwf_complex));
-                memcpy(fftwInput + num_last, fftInData, num_written * sizeof(fftwf_complex));
-                memcpy(fftLastData, fftwInput, fftSizeInternal * sizeof(fftwf_complex));
-                execute = true;
-            }
-        }
-#else
         if (num_written >= fftSizeInternal) {
             execute = true;
             memcpy(fftInput, fftInData, fftSizeInternal * sizeof(liquid_float_complex));
@@ -485,7 +381,6 @@ void SpectrumVisualProcessor::process() {
                 execute = true;
             }
         }
-#endif
         
         if (execute) {
             SpectrumVisualData *output = outputBuffers.getBuffer();
@@ -503,22 +398,6 @@ void SpectrumVisualProcessor::process() {
             
             float fft_ceil = 0, fft_floor = 1;
 
-#if USE_FFTW3
-            fftwf_execute(fftw_plan);
-            
-            for (int i = 0, iMax = fftSizeInternal / 2; i < iMax; i++) {
-                float a = fftwOutput[i][0];
-                float b = fftwOutput[i][1];
-                float c = sqrt(a * a + b * b);
-                
-                float x = fftwOutput[fftSizeInternal / 2 + i][0];
-                float y = fftwOutput[fftSizeInternal / 2 + i][1];
-                float z = sqrt(x * x + y * y);
-                
-                fft_result[i] = (z);
-                fft_result[fftSizeInternal / 2 + i] = (c);
-            }
-#else
             fft_execute(fftPlan);
             
             for (int i = 0, iMax = fftSizeInternal / 2; i < iMax; i++) {
@@ -533,7 +412,6 @@ void SpectrumVisualProcessor::process() {
                 fft_result[i] = (z);
                 fft_result[fftSizeInternal / 2 + i] = (c);
             }
-#endif
             
             if (newResampler && lastView) {
                 if (bwDiff < 0) {
diff --git a/src/process/SpectrumVisualProcessor.h b/src/process/SpectrumVisualProcessor.h
index 35c99eb..80a5d05 100644
--- a/src/process/SpectrumVisualProcessor.h
+++ b/src/process/SpectrumVisualProcessor.h
@@ -4,10 +4,6 @@
 #include "DemodDefs.h"
 #include <cmath>
 
-#if USE_FFTW3
-#include "fftw3.h"
-#endif
-
 #define SPECTRUM_VZM 2
 #define PEAK_RESET_COUNT 30
 
@@ -68,13 +64,8 @@ private:
     long lastBandwidth;
     bool lastView;
 
-#if USE_FFTW3
-    fftwf_complex *fftwInput, *fftwOutput, *fftInData, *fftLastData;
-    fftwf_plan fftw_plan;
-#else
     liquid_float_complex *fftInput, *fftOutput, *fftInData, *fftLastData;
     fftplan fftPlan;
-#endif
 
     unsigned int lastDataSize;