def build_extensions(self):
        c = self.compiler.compiler_type

        if self.omp not in ('0', '1', True, False):
            raise ValueError("Invalid omp argument. Mut be '0' or '1'.")
        self.omp = int(self.omp)

        if self.omp:
            if not hasattr(self, "_printed_omp_message"):
                self._printed_omp_message = True
                print("\n#################################")
                print("# Compiling with OpenMP support #")
                print("#################################\n")
            # More portable to pass -fopenmp to linker.
            # self.libraries += ['gomp']
            if self.compiler.compiler_type == 'msvc':
                openmpflag = '/openmp'
                compileflags = COMPILE_FLAGS_MSVC
            else:
                openmpflag = '-fopenmp'
                compileflags = COMPILE_FLAGS
            for e in self.extensions:
                e.extra_compile_args = list(set(e.extra_compile_args).union(compileflags))
                if openmpflag not in e.extra_compile_args:
                    e.extra_compile_args += [openmpflag]
                if openmpflag not in e.extra_link_args:
                    e.extra_link_args += [openmpflag]

        build_ext_.build_extensions(self)

    def build_extensions(self):
        ct = self.compiler.compiler_type
        opts = self.c_opts.get(ct, [])
        if ct == 'unix':
            opts.append('-DVERSION_INFO="%s"' % self.distribution.get_version())
            opts.append(cpp_flag(self.compiler))
            if has_flag(self.compiler, '-fvisibility=hidden'):
                opts.append('-fvisibility=hidden')
        elif ct == 'msvc':
            opts.append('/DVERSION_INFO=\\"%s\\"' % self.distribution.get_version())

        # extend include dirs here (don't assume numpy/pybind11 are installed when first run, since
        # pip could have installed them as part of executing this script
        import pybind11
        import numpy as np
        for ext in self.extensions:
            ext.extra_compile_args.extend(opts)
            ext.extra_link_args.extend(self.link_opts.get(ct, []))
            ext.include_dirs.extend([
                # Path to pybind11 headers
                pybind11.get_include(),
                pybind11.get_include(True),

                # Path to numpy headers
                np.get_include()
            ])

        build_ext.build_extensions(self)

    def build_extensions(self):
        ct = self.compiler.compiler_type
        opts = self.c_opts.get(ct, [])
        link_args = []

        if ct == 'unix':
            opts.append('-DVERSION_INFO="%s"' % self.distribution.get_version())
            opts.append(cpp_flag(self.compiler))
            if has_flag(self.compiler, '-fvisibility=hidden'):
                opts.append('-fvisibility=hidden')
        elif ct == 'msvc':
            opts.append('/DVERSION_INFO=\\"%s\\"' % self.distribution.get_version())

        if has_flag(self.compiler, '-fopenmp'):
            opts.append('-fopenmp')
            link_args.append('-fopenmp')
        elif has_flag(self.compiler, '-openmp'):
            opts.append('-openmp')
            link_args.append('-openmp')

        for ext in self.extensions:
            ext.extra_compile_args = opts
            ext.extra_link_args = link_args

        build_ext.build_extensions(self)

    def build_extensions(self):
        # set compiler flags
        c = self.compiler.compiler_type
        if self.copt.has_key(c):
           for e in self.extensions:
               e.extra_compile_args = self.copt[ c ]
        if self.lopt.has_key(c):
            for e in self.extensions:
                e.extra_link_args = self.lopt[ c ]

        # handle numpy
        if not disabled_numpy:
            try:
                import numpy
                jpypeLib.define_macros.append(('HAVE_NUMPY', 1))
                jpypeLib.include_dirs.append(numpy.get_include())
                warnings.warn("Turned ON Numpy support for fast Java array access",
                               FeatureNotice)
            except ImportError:
                pass
        else:
            warnings.warn("Turned OFF Numpy support for fast Java array access",
                          FeatureNotice)
        
        # has to be last call
        build_ext.build_extensions(self)

 def build_extensions(self):
     # Stop GCC complaining about -Wstrict-prototypes in C++ code
     try:
         self.compiler.compiler_so.remove('-Wstrict-prototypes')
     except ValueError:
         pass
     build_ext.build_extensions(self)

    def build_extensions(self):
        if sys.platform == 'darwin':
            all_flags = ['-stdlib=libc++', '-mmacosx-version-min=10.7']
            if has_flag(self.compiler, [all_flags[0]]):
                self.c_opts['unix'] += [all_flags[0]]
            elif has_flag(self.compiler, all_flags):
                self.c_opts['unix'] += all_flags
            else:
                raise RuntimeError(
                    'libc++ is needed! Failed to compile with {} and {}.'.
                    format(" ".join(all_flags), all_flags[0])
                )
        ct = self.compiler.compiler_type
        opts = self.c_opts.get(ct, [])
        extra_link_args = []

        if coverage:
            coverage_option = '--coverage'
            opts.append(coverage_option)
            extra_link_args.append(coverage_option)

        if ct == 'unix':
            opts.append('-DVERSION_INFO="%s"' % self.distribution.get_version())
            opts.append(cpp_flag(self.compiler))
            if has_flag(self.compiler, ['-fvisibility=hidden']):
                opts.append('-fvisibility=hidden')
        elif ct == 'msvc':
            opts.append(
                '/DVERSION_INFO=\\"%s\\"' % self.distribution.get_version()
            )
        for ext in self.extensions:
            ext.extra_compile_args = opts
            ext.extra_link_args = extra_link_args
        build_ext.build_extensions(self)

    def build_extensions(self):
        # Get 64-bitness
        c = self.compiler.compiler_type
        print("Compiling with %s (64bit=%s)" % (c, str(is_64bits)))
        #print("=== compiler attributes ===")
        #print("\n".join("%s: %s"%(k, v) for k, v in sorted(self.compiler.__dict__.items())))
        #print("=== build_ext attributes ===")
        #print("\n".join("%s: %s"%(k, v) for k, v in self.__dict__.items()))
        #sys.exit(1)

        # OpenMP build options
        if enable_openmp:
            if c in copt:
                for e in self.extensions:
                    e.extra_compile_args = copt[c]
            if c in lopt:
                for e in self.extensions:
                    e.extra_link_args = lopt[c]

        # Platform-specific build options
        if c in platform_lopt:
            for e in self.extensions:
                e.extra_link_args = platform_lopt[c]

        if c in platform_copt:
            for e in self.extensions:
                e.extra_compile_args = platform_copt[c]

        build_ext.build_extensions(self)

    def build_extensions(self):
        from numpy.distutils.misc_util import get_numpy_include_dirs

        for e in self.extensions:
            e.include_dirs.extend(get_numpy_include_dirs())

        build_ext.build_extensions(self)

    def build_extensions(self):
        """
        Sets up the compiler arguments
        """
        try:
            # Filter compiler arguments
            self.compiler.compiler = [arg for arg in self.compiler.compiler
                                      if arg not in self.ignored_arguments]
            self.compiler.compiler_so = [arg
                                         for arg in self.compiler.compiler_so
                                         if arg not in self.ignored_arguments]
        except AttributeError:
            # Incompatible compiler
            pass

        compiler = self.compiler.compiler_type
        if compiler in self.compile_args:
            for ext in self.extensions:
                ext.extra_compile_args = self.compile_args[compiler]

        if compiler in self.linker_args:
            for ext in self.extensions:
                ext.extra_link_args = self.linker_args[compiler]

        build_ext.build_extensions(self)

 def build_extensions(self):
     if sys.platform == "win32":
         from distutils.msvccompiler import MSVCCompiler
         if isinstance(self.compiler, MSVCCompiler):
             # disable Language Extensions not compatible with ANSI C
             for ext in self.extensions:
                 ext.extra_compile_args.append("/Za")
     build_ext.build_extensions(self)

 def build_extensions(self):
     self.compiler.src_extensions.append(".cu")
     self.compiler.set_executable("compiler_so", "nvcc")
     self.compiler.set_executable("linker_so", "nvcc --shared")
     if hasattr(self.compiler, "_c_extensions"):
         self.compiler._c_extensions.append(".cu")  # needed for Windows
     self.compiler.spawn = self.spawn
     build_ext.build_extensions(self)

 def build_extensions(self):
   compiler = self.compiler.compiler_type
   print('COMPILER',compiler)
   args     = BUILD_ARGS[compiler]
   for ext in self.extensions:
       ext.extra_compile_args = args
   print('COMPILER ARGUMENTS',ext.extra_compile_args)
   _build_ext.build_extensions(self)

    def build_extensions(self):
        import pkg_resources
        numpy_incl = pkg_resources.resource_filename('numpy', 'core/include')

        for ext in self.extensions:
            if (hasattr(ext, 'include_dirs') and
                    not numpy_incl in ext.include_dirs):
                ext.include_dirs.append(numpy_incl)
        _build_ext.build_extensions(self)

 def build_extensions(self):
     compiler_type = self.compiler.compiler_type
     if compiler_type in "unix":
         for ext in self.extensions:
             # on some Unix-like systems, such as Linux, the libc math
             # library is not linked by default:
             # https://github.com/cython/cython/issues/1585
             ext.extra_link_args.append("-lm")
     build_ext.build_extensions(self)

 def build_extensions(self):
     ct = self.compiler.compiler_type
     opts = self.c_opts.get(ct, [])
     import pybind11
     for ext in self.extensions:
         ext.extra_compile_args = opts
         ext.include_dirs.append(pybind11.get_include())
         ext.include_dirs.append(pybind11.get_include(user=True))
     build_ext.build_extensions(self)

    def build_extensions(self):
        c = self.compiler
        opts = [v for k, v in compiler_opts.items() if isinstance(c, k)]
        for e in self.extensions:
            for o in opts:
                for attrib, value in o.items():
                    getattr(e, attrib).extend(value)

        build_ext.build_extensions(self)

 def build_extensions(self):
     c = self.compiler.compiler_type
     if c in extra_compile_args:
        for e in self.extensions:
            e.extra_compile_args = extra_compile_args[c]
     if c in extra_link_args:
         for e in self.extensions:
             e.extra_link_args = extra_link_args[c]
     build_ext.build_extensions(self)

    def build_extensions(self):
        extra_compile_args = ['-g0']
        for c in ['-w', '-Ofast', '-ffast-math', '-march=native']:
            if has_flag(self.compiler, c):
                extra_compile_args.append(c)

        for e in self.extensions:
            e.extra_compile_args += extra_compile_args
            e.include_dirs.extend([get_include()])
        build_ext.build_extensions(self)

 def build_extensions(self):
     compiler = self.compiler.compiler_type
     if compiler == 'msvc':
         extra = ('/D_CRT_SECURE_NO_DEPRECATE',
                  '/EHsc', '/wd4355', '/wd4800')
     else:
         extra = ('-Wno-switch',)
     for ext in self.extensions:
         ext.extra_compile_args += extra
     build_ext.build_extensions(self)

 def build_extensions(self):
     c = self.compiler.compiler_type
     print('Compiler:', c)
     if c in copt:
         for e in self.extensions:
             e.extra_compile_args = copt[c]
     if c in lopt:
         for e in self.extensions:
             e.extra_link_args = lopt[c]
     build_ext.build_extensions(self)