diff --git a/eight_bit_int_gemm/Android.mk b/eight_bit_int_gemm/Android.mk
index 51b1c8f..bca39c5 100644
--- a/eight_bit_int_gemm/Android.mk
+++ b/eight_bit_int_gemm/Android.mk
@@ -34,7 +34,9 @@
 
 LOCAL_CPP_EXTENSION := .cc
 LOCAL_SRC_FILES:= eight_bit_int_gemm.cc
+
 LOCAL_CFLAGS += -no-integrated-as -std=c++11
+LOCAL_CFLAGS += -DGEMMLOWP_USE_OLD_ANDROID_SDK
 LOCAL_C_INCLUDES += external/gemmlowp/
 LOCAL_NDK_STL_VARIANT := stlport_static
 
diff --git a/eight_bit_int_gemm/eight_bit_int_gemm.h b/eight_bit_int_gemm/eight_bit_int_gemm.h
index 8929ae5..37586bd 100644
--- a/eight_bit_int_gemm/eight_bit_int_gemm.h
+++ b/eight_bit_int_gemm/eight_bit_int_gemm.h
@@ -17,13 +17,6 @@
 #ifndef GEMMLOWP_EIGHT_BIT_INT_GEMM_EIGHT_BIT_INT_GEMM_H_
 #define GEMMLOWP_EIGHT_BIT_INT_GEMM_EIGHT_BIT_INT_GEMM_H_
 
-#if defined ANDROID || defined __ANDROID__
-#include <android/api-level.h>
-#if __ANDROID_API__ < 22
-#define GEMMLOWP_USE_OLD_ANDROID_SDK
-#endif
-#endif
-
 #ifndef GEMMLOWP_USE_OLD_ANDROID_SDK
 #include <cstdint>
 #else
diff --git a/profiling/instrumentation.h b/profiling/instrumentation.h
index 2fbcda8..a443f96 100644
--- a/profiling/instrumentation.h
+++ b/profiling/instrumentation.h
@@ -27,13 +27,6 @@
 #include <pthread.h>
 #include <cstdio>
 
-#if defined ANDROID || defined __ANDROID__
-#include <android/api-level.h>
-#if __ANDROID_API__ < 22
-#define GEMMLOWP_USE_OLD_ANDROID_SDK
-#endif
-#endif
-
 #ifndef GEMMLOWP_USE_OLD_ANDROID_SDK
 #include <cstdint>
 #else
