LCOV - code coverage report
Current view: top level - src/hfxbase - hfx_contraction_methods.F (source / functions) Hit Total Coverage
Test: CP2K Regtests (git:f515968) Lines: 4414 5059 87.3 %
Date: 2022-07-03 19:52:34 Functions: 83 83 100.0 %

          Line data    Source code
       1             : !--------------------------------------------------------------------------------------------------!
       2             : !   CP2K: A general program to perform molecular dynamics simulations                              !
       3             : !   Copyright 2000-2022 CP2K developers group <https://cp2k.org>                                   !
       4             : !                                                                                                  !
       5             : !   SPDX-License-Identifier: GPL-2.0-or-later                                                      !
       6             : !--------------------------------------------------------------------------------------------------!
       7             : 
       8             : ! **************************************************************************************************
       9             : !> \brief Contains routines for contraction without dgemms. PLEASE DO NOT MODIFY.
      10             : !> \notes Contains specific routines for contraction. The compiler flag
      11             : !>        -D__MAX_CONTR defines the maximum angular momentum up to which
      12             : !>        specialized code will be used. Default setting is d-functions.
      13             : !>        Increasing -D__MAX_CONTR produces faster code but might overburden
      14             : !>        the optimization capabilities of some poor compilers.
      15             : !>        This file contains specific code up to g-functions. If you need more
      16             : !>        look at cp2k/tools/hfx_tools/contraction/
      17             : !> \par History
      18             : !>      07.2009 created [Manuel Guidon]
      19             : !> \author Manuel Guidon
      20             : ! **************************************************************************************************
      21             : 
      22             : MODULE hfx_contraction_methods
      23             : 
      24             : !** This defines the default behaviour
      25             : #ifndef __MAX_CONTR
      26             : #define __MAX_CONTR 2
      27             : #endif
      28             : 
      29             :    USE kinds, ONLY: dp
      30             : #include "../base/base_uses.f90"
      31             : 
      32             :    IMPLICIT NONE
      33             : 
      34             :    PRIVATE
      35             :    PUBLIC :: contract
      36             : 
      37             : CONTAINS
      38             : 
      39             : ! **************************************************************************************************
      40             : !> \brief ...
      41             : !> \param ncoa ...
      42             : !> \param ncob ...
      43             : !> \param ncoc ...
      44             : !> \param ncod ...
      45             : !> \param nsoa ...
      46             : !> \param nsob ...
      47             : !> \param nsoc ...
      48             : !> \param nsod ...
      49             : !> \param n_a ...
      50             : !> \param n_b ...
      51             : !> \param n_c ...
      52             : !> \param n_d ...
      53             : !> \param nl_a ...
      54             : !> \param nl_b ...
      55             : !> \param nl_c ...
      56             : !> \param nl_d ...
      57             : !> \param work ...
      58             : !> \param sphi_a ...
      59             : !> \param sphi_b ...
      60             : !> \param sphi_c ...
      61             : !> \param sphi_d ...
      62             : !> \param primitives ...
      63             : !> \param buffer1 ...
      64             : !> \param buffer2 ...
      65             : ! **************************************************************************************************
      66   383843208 :    SUBROUTINE contract(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
      67   383843208 :                        n_a, n_b, n_c, n_d, nl_a, nl_b, nl_c, nl_d, work, &
      68   383843208 :                        sphi_a, sphi_b, sphi_c, sphi_d, &
      69   383843208 :                        primitives, &
      70   383843208 :                        buffer1, buffer2)
      71             : 
      72             :       INTEGER, INTENT(IN)         :: ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
      73             :                                      n_a, n_b, n_c, n_d, nl_a, nl_b, nl_c, nl_d
      74             :       REAL(dp), DIMENSION(ncoa*ncob*ncoc*ncod), INTENT(IN) :: work
      75             :       REAL(dp), DIMENSION(ncoa, nsoa*nl_a), INTENT(IN)   :: sphi_a
      76             :       REAL(dp), DIMENSION(ncob, nsob*nl_b), INTENT(IN)   :: sphi_b
      77             :       REAL(dp), DIMENSION(ncoc, nsoc*nl_c), INTENT(IN)   :: sphi_c
      78             :       REAL(dp), DIMENSION(ncod, nsod*nl_d), INTENT(IN)   :: sphi_d
      79             : 
      80             :       REAL(dp), DIMENSION(nsoa*nl_a, nsob*nl_b, nsoc*nl_c, nsod*nl_d) :: primitives
      81             :       REAL(dp), DIMENSION(ncoa*ncob*ncoc*ncod)  :: buffer1, buffer2
      82             : 
      83             : #if !defined(__LIBINT)
      84             :       MARK_USED(ncoa)
      85             :       MARK_USED(ncob)
      86             :       MARK_USED(ncoc)
      87             :       MARK_USED(ncod)
      88             :       MARK_USED(nsoa)
      89             :       MARK_USED(nsob)
      90             :       MARK_USED(nsoc)
      91             :       MARK_USED(nsod)
      92             :       MARK_USED(n_a)
      93             :       MARK_USED(n_b)
      94             :       MARK_USED(n_c)
      95             :       MARK_USED(n_d)
      96             :       MARK_USED(nl_a)
      97             :       MARK_USED(nl_b)
      98             :       MARK_USED(nl_c)
      99             :       MARK_USED(nl_d)
     100             :       MARK_USED(sphi_a)
     101             :       MARK_USED(sphi_b)
     102             :       MARK_USED(sphi_c)
     103             :       MARK_USED(sphi_d)
     104             :       MARK_USED(work)
     105             :       MARK_USED(primitives)
     106             :       MARK_USED(buffer1)
     107             :       MARK_USED(buffer2)
     108             :       CPABORT("libint not compiled in")
     109             : #else
     110   653629478 :       SELECT CASE (n_a)
     111             :       CASE (0)
     112   607520283 :          SELECT CASE (n_b)
     113             :          CASE (0)
     114   409408569 :             SELECT CASE (n_c)
     115             :             CASE (0)
     116   346618978 :                SELECT CASE (n_d)
     117             :                CASE (0)
     118             : #if __MAX_CONTR > 0 || __MAX_CONTR == 0
     119             :                   CALL contract_ssss(work, &
     120             :                                      nl_a, nl_b, nl_c, nl_d, &
     121             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
     122             :                                      primitives, &
     123   114580832 :                                      buffer1, buffer2)
     124             : #else
     125             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
     126             :                                         work, nl_a, nl_b, nl_c, nl_d, &
     127             :                                         sphi_a, &
     128             :                                         sphi_b, &
     129             :                                         sphi_c, &
     130             :                                         sphi_d, &
     131             :                                         primitives, &
     132             :                                         buffer1, buffer2)
     133             : #endif
     134             :                CASE (1)
     135             : #if __MAX_CONTR > 1 || __MAX_CONTR == 1
     136             :                   CALL contract_sssp(work, &
     137             :                                      nl_a, nl_b, nl_c, nl_d, &
     138             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
     139             :                                      primitives, &
     140    27248635 :                                      buffer1, buffer2)
     141             : #else
     142             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
     143             :                                         work, nl_a, nl_b, nl_c, nl_d, &
     144             :                                         sphi_a, &
     145             :                                         sphi_b, &
     146             :                                         sphi_c, &
     147             :                                         sphi_d, &
     148             :                                         primitives, &
     149             :                                         buffer1, buffer2)
     150             : #endif
     151             :                CASE (2)
     152             : #if __MAX_CONTR > 2 || __MAX_CONTR == 2
     153             :                   CALL contract_sssd(work, &
     154             :                                      nl_a, nl_b, nl_c, nl_d, &
     155             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
     156             :                                      primitives, &
     157     2386364 :                                      buffer1, buffer2)
     158             : #else
     159             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
     160             :                                         work, nl_a, nl_b, nl_c, nl_d, &
     161             :                                         sphi_a, &
     162             :                                         sphi_b, &
     163             :                                         sphi_c, &
     164             :                                         sphi_d, &
     165             :                                         primitives, &
     166             :                                         buffer1, buffer2)
     167             : #endif
     168             :                CASE (3)
     169             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
     170             :                   CALL contract_sssf(work, &
     171             :                                      nl_a, nl_b, nl_c, nl_d, &
     172             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
     173             :                                      primitives, &
     174             :                                      buffer1, buffer2)
     175             : #else
     176             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
     177             :                                         work, nl_a, nl_b, nl_c, nl_d, &
     178             :                                         sphi_a, &
     179             :                                         sphi_b, &
     180             :                                         sphi_c, &
     181             :                                         sphi_d, &
     182             :                                         primitives, &
     183       17903 :                                         buffer1, buffer2)
     184             : #endif
     185             :                CASE (4)
     186             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
     187             :                   CALL contract_sssg(work, &
     188             :                                      nl_a, nl_b, nl_c, nl_d, &
     189             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
     190             :                                      primitives, &
     191             :                                      buffer1, buffer2)
     192             : #else
     193             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
     194             :                                         work, nl_a, nl_b, nl_c, nl_d, &
     195             :                                         sphi_a, &
     196             :                                         sphi_b, &
     197             :                                         sphi_c, &
     198             :                                         sphi_d, &
     199             :                                         primitives, &
     200           0 :                                         buffer1, buffer2)
     201             : #endif
     202             :                CASE DEFAULT
     203             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
     204             :                                         work, nl_a, nl_b, nl_c, nl_d, &
     205             :                                         sphi_a, &
     206             :                                         sphi_b, &
     207             :                                         sphi_c, &
     208             :                                         sphi_d, &
     209             :                                         primitives, &
     210   144233734 :                                         buffer1, buffer2)
     211             :                END SELECT
     212             :             CASE (1)
     213   159269249 :                SELECT CASE (n_d)
     214             :                CASE (0)
     215             : #if __MAX_CONTR > 1 || __MAX_CONTR == 1
     216             :                   CALL contract_ssps(work, &
     217             :                                      nl_a, nl_b, nl_c, nl_d, &
     218             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
     219             :                                      primitives, &
     220    64936245 :                                      buffer1, buffer2)
     221             : #else
     222             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
     223             :                                         work, nl_a, nl_b, nl_c, nl_d, &
     224             :                                         sphi_a, &
     225             :                                         sphi_b, &
     226             :                                         sphi_c, &
     227             :                                         sphi_d, &
     228             :                                         primitives, &
     229             :                                         buffer1, buffer2)
     230             : #endif
     231             :                CASE (1)
     232             : #if __MAX_CONTR > 1 || __MAX_CONTR == 1
     233             :                   CALL contract_sspp(work, &
     234             :                                      nl_a, nl_b, nl_c, nl_d, &
     235             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
     236             :                                      primitives, &
     237    20962408 :                                      buffer1, buffer2)
     238             : #else
     239             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
     240             :                                         work, nl_a, nl_b, nl_c, nl_d, &
     241             :                                         sphi_a, &
     242             :                                         sphi_b, &
     243             :                                         sphi_c, &
     244             :                                         sphi_d, &
     245             :                                         primitives, &
     246             :                                         buffer1, buffer2)
     247             : #endif
     248             :                CASE (2)
     249             : #if __MAX_CONTR > 2 || __MAX_CONTR == 2
     250             :                   CALL contract_sspd(work, &
     251             :                                      nl_a, nl_b, nl_c, nl_d, &
     252             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
     253             :                                      primitives, &
     254     1875419 :                                      buffer1, buffer2)
     255             : #else
     256             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
     257             :                                         work, nl_a, nl_b, nl_c, nl_d, &
     258             :                                         sphi_a, &
     259             :                                         sphi_b, &
     260             :                                         sphi_c, &
     261             :                                         sphi_d, &
     262             :                                         primitives, &
     263             :                                         buffer1, buffer2)
     264             : #endif
     265             :                CASE (3)
     266             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
     267             :                   CALL contract_sspf(work, &
     268             :                                      nl_a, nl_b, nl_c, nl_d, &
     269             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
     270             :                                      primitives, &
     271             :                                      buffer1, buffer2)
     272             : #else
     273             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
     274             :                                         work, nl_a, nl_b, nl_c, nl_d, &
     275             :                                         sphi_a, &
     276             :                                         sphi_b, &
     277             :                                         sphi_c, &
     278             :                                         sphi_d, &
     279             :                                         primitives, &
     280       30340 :                                         buffer1, buffer2)
     281             : #endif
     282             :                CASE (4)
     283             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
     284             :                   CALL contract_sspg(work, &
     285             :                                      nl_a, nl_b, nl_c, nl_d, &
     286             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
     287             :                                      primitives, &
     288             :                                      buffer1, buffer2)
     289             : #else
     290             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
     291             :                                         work, nl_a, nl_b, nl_c, nl_d, &
     292             :                                         sphi_a, &
     293             :                                         sphi_b, &
     294             :                                         sphi_c, &
     295             :                                         sphi_d, &
     296             :                                         primitives, &
     297           0 :                                         buffer1, buffer2)
     298             : #endif
     299             :                CASE DEFAULT
     300             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
     301             :                                         work, nl_a, nl_b, nl_c, nl_d, &
     302             :                                         sphi_a, &
     303             :                                         sphi_b, &
     304             :                                         sphi_c, &
     305             :                                         sphi_d, &
     306             :                                         primitives, &
     307    87804412 :                                         buffer1, buffer2)
     308             :                END SELECT
     309             :             CASE (2)
     310    10470720 :                SELECT CASE (n_d)
     311             :                CASE (0)
     312             : #if __MAX_CONTR > 2 || __MAX_CONTR == 2
     313             :                   CALL contract_ssds(work, &
     314             :                                      nl_a, nl_b, nl_c, nl_d, &
     315             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
     316             :                                      primitives, &
     317     3879936 :                                      buffer1, buffer2)
     318             : #else
     319             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
     320             :                                         work, nl_a, nl_b, nl_c, nl_d, &
     321             :                                         sphi_a, &
     322             :                                         sphi_b, &
     323             :                                         sphi_c, &
     324             :                                         sphi_d, &
     325             :                                         primitives, &
     326             :                                         buffer1, buffer2)
     327             : #endif
     328             :                CASE (1)
     329             : #if __MAX_CONTR > 2 || __MAX_CONTR == 2
     330             :                   CALL contract_ssdp(work, &
     331             :                                      nl_a, nl_b, nl_c, nl_d, &
     332             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
     333             :                                      primitives, &
     334     2067235 :                                      buffer1, buffer2)
     335             : #else
     336             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
     337             :                                         work, nl_a, nl_b, nl_c, nl_d, &
     338             :                                         sphi_a, &
     339             :                                         sphi_b, &
     340             :                                         sphi_c, &
     341             :                                         sphi_d, &
     342             :                                         primitives, &
     343             :                                         buffer1, buffer2)
     344             : #endif
     345             :                CASE (2)
     346             : #if __MAX_CONTR > 2 || __MAX_CONTR == 2
     347             :                   CALL contract_ssdd(work, &
     348             :                                      nl_a, nl_b, nl_c, nl_d, &
     349             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
     350             :                                      primitives, &
     351      573993 :                                      buffer1, buffer2)
     352             : #else
     353             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
     354             :                                         work, nl_a, nl_b, nl_c, nl_d, &
     355             :                                         sphi_a, &
     356             :                                         sphi_b, &
     357             :                                         sphi_c, &
     358             :                                         sphi_d, &
     359             :                                         primitives, &
     360             :                                         buffer1, buffer2)
     361             : #endif
     362             :                CASE (3)
     363             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
     364             :                   CALL contract_ssdf(work, &
     365             :                                      nl_a, nl_b, nl_c, nl_d, &
     366             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
     367             :                                      primitives, &
     368             :                                      buffer1, buffer2)
     369             : #else
     370             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
     371             :                                         work, nl_a, nl_b, nl_c, nl_d, &
     372             :                                         sphi_a, &
     373             :                                         sphi_b, &
     374             :                                         sphi_c, &
     375             :                                         sphi_d, &
     376             :                                         primitives, &
     377        7428 :                                         buffer1, buffer2)
     378             : #endif
     379             :                CASE (4)
     380             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
     381             :                   CALL contract_ssdg(work, &
     382             :                                      nl_a, nl_b, nl_c, nl_d, &
     383             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
     384             :                                      primitives, &
     385             :                                      buffer1, buffer2)
     386             : #else
     387             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
     388             :                                         work, nl_a, nl_b, nl_c, nl_d, &
     389             :                                         sphi_a, &
     390             :                                         sphi_b, &
     391             :                                         sphi_c, &
     392             :                                         sphi_d, &
     393             :                                         primitives, &
     394           0 :                                         buffer1, buffer2)
     395             : #endif
     396             :                CASE DEFAULT
     397             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
     398             :                                         work, nl_a, nl_b, nl_c, nl_d, &
     399             :                                         sphi_a, &
     400             :                                         sphi_b, &
     401             :                                         sphi_c, &
     402             :                                         sphi_d, &
     403             :                                         primitives, &
     404     6528592 :                                         buffer1, buffer2)
     405             :                END SELECT
     406             :             CASE (3)
     407       88195 :                SELECT CASE (n_d)
     408             :                CASE (0)
     409             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
     410             :                   CALL contract_ssfs(work, &
     411             :                                      nl_a, nl_b, nl_c, nl_d, &
     412             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
     413             :                                      primitives, &
     414             :                                      buffer1, buffer2)
     415             : #else
     416             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
     417             :                                         work, nl_a, nl_b, nl_c, nl_d, &
     418             :                                         sphi_a, &
     419             :                                         sphi_b, &
     420             :                                         sphi_c, &
     421             :                                         sphi_d, &
     422             :                                         primitives, &
     423       26003 :                                         buffer1, buffer2)
     424             : #endif
     425             :                CASE (1)
     426             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
     427             :                   CALL contract_ssfp(work, &
     428             :                                      nl_a, nl_b, nl_c, nl_d, &
     429             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
     430             :                                      primitives, &
     431             :                                      buffer1, buffer2)
     432             : #else
     433             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
     434             :                                         work, nl_a, nl_b, nl_c, nl_d, &
     435             :                                         sphi_a, &
     436             :                                         sphi_b, &
     437             :                                         sphi_c, &
     438             :                                         sphi_d, &
     439             :                                         primitives, &
     440       23437 :                                         buffer1, buffer2)
     441             : #endif
     442             :                CASE (2)
     443             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
     444             :                   CALL contract_ssfd(work, &
     445             :                                      nl_a, nl_b, nl_c, nl_d, &
     446             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
     447             :                                      primitives, &
     448             :                                      buffer1, buffer2)
     449             : #else
     450             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
     451             :                                         work, nl_a, nl_b, nl_c, nl_d, &
     452             :                                         sphi_a, &
     453             :                                         sphi_b, &
     454             :                                         sphi_c, &
     455             :                                         sphi_d, &
     456             :                                         primitives, &
     457        5735 :                                         buffer1, buffer2)
     458             : #endif
     459             :                CASE (3)
     460             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
     461             :                   CALL contract_ssff(work, &
     462             :                                      nl_a, nl_b, nl_c, nl_d, &
     463             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
     464             :                                      primitives, &
     465             :                                      buffer1, buffer2)
     466             : #else
     467             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
     468             :                                         work, nl_a, nl_b, nl_c, nl_d, &
     469             :                                         sphi_a, &
     470             :                                         sphi_b, &
     471             :                                         sphi_c, &
     472             :                                         sphi_d, &
     473             :                                         primitives, &
     474        7017 :                                         buffer1, buffer2)
     475             : #endif
     476             :                CASE (4)
     477             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
     478             :                   CALL contract_ssfg(work, &
     479             :                                      nl_a, nl_b, nl_c, nl_d, &
     480             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
     481             :                                      primitives, &
     482             :                                      buffer1, buffer2)
     483             : #else
     484             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
     485             :                                         work, nl_a, nl_b, nl_c, nl_d, &
     486             :                                         sphi_a, &
     487             :                                         sphi_b, &
     488             :                                         sphi_c, &
     489             :                                         sphi_d, &
     490             :                                         primitives, &
     491           0 :                                         buffer1, buffer2)
     492             : #endif
     493             :                CASE DEFAULT
     494             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
     495             :                                         work, nl_a, nl_b, nl_c, nl_d, &
     496             :                                         sphi_a, &
     497             :                                         sphi_b, &
     498             :                                         sphi_c, &
     499             :                                         sphi_d, &
     500             :                                         primitives, &
     501       62192 :                                         buffer1, buffer2)
     502             :                END SELECT
     503             :             CASE (4)
     504           0 :                SELECT CASE (n_d)
     505             :                CASE (0)
     506             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
     507             :                   CALL contract_ssgs(work, &
     508             :                                      nl_a, nl_b, nl_c, nl_d, &
     509             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
     510             :                                      primitives, &
     511             :                                      buffer1, buffer2)
     512             : #else
     513             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
     514             :                                         work, nl_a, nl_b, nl_c, nl_d, &
     515             :                                         sphi_a, &
     516             :                                         sphi_b, &
     517             :                                         sphi_c, &
     518             :                                         sphi_d, &
     519             :                                         primitives, &
     520           0 :                                         buffer1, buffer2)
     521             : #endif
     522             :                CASE (1)
     523             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
     524             :                   CALL contract_ssgp(work, &
     525             :                                      nl_a, nl_b, nl_c, nl_d, &
     526             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
     527             :                                      primitives, &
     528             :                                      buffer1, buffer2)
     529             : #else
     530             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
     531             :                                         work, nl_a, nl_b, nl_c, nl_d, &
     532             :                                         sphi_a, &
     533             :                                         sphi_b, &
     534             :                                         sphi_c, &
     535             :                                         sphi_d, &
     536             :                                         primitives, &
     537           0 :                                         buffer1, buffer2)
     538             : #endif
     539             :                CASE (2)
     540             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
     541             :                   CALL contract_ssgd(work, &
     542             :                                      nl_a, nl_b, nl_c, nl_d, &
     543             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
     544             :                                      primitives, &
     545             :                                      buffer1, buffer2)
     546             : #else
     547             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
     548             :                                         work, nl_a, nl_b, nl_c, nl_d, &
     549             :                                         sphi_a, &
     550             :                                         sphi_b, &
     551             :                                         sphi_c, &
     552             :                                         sphi_d, &
     553             :                                         primitives, &
     554           0 :                                         buffer1, buffer2)
     555             : #endif
     556             :                CASE (3)
     557             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
     558             :                   CALL contract_ssgf(work, &
     559             :                                      nl_a, nl_b, nl_c, nl_d, &
     560             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
     561             :                                      primitives, &
     562             :                                      buffer1, buffer2)
     563             : #else
     564             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
     565             :                                         work, nl_a, nl_b, nl_c, nl_d, &
     566             :                                         sphi_a, &
     567             :                                         sphi_b, &
     568             :                                         sphi_c, &
     569             :                                         sphi_d, &
     570             :                                         primitives, &
     571           0 :                                         buffer1, buffer2)
     572             : #endif
     573             :                CASE (4)
     574             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
     575             :                   CALL contract_ssgg(work, &
     576             :                                      nl_a, nl_b, nl_c, nl_d, &
     577             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
     578             :                                      primitives, &
     579             :                                      buffer1, buffer2)
     580             : #else
     581             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
     582             :                                         work, nl_a, nl_b, nl_c, nl_d, &
     583             :                                         sphi_a, &
     584             :                                         sphi_b, &
     585             :                                         sphi_c, &
     586             :                                         sphi_d, &
     587             :                                         primitives, &
     588           0 :                                         buffer1, buffer2)
     589             : #endif
     590             :                CASE DEFAULT
     591             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
     592             :                                         work, nl_a, nl_b, nl_c, nl_d, &
     593             :                                         sphi_a, &
     594             :                                         sphi_b, &
     595             :                                         sphi_c, &
     596             :                                         sphi_d, &
     597             :                                         primitives, &
     598           0 :                                         buffer1, buffer2)
     599             :                END SELECT
     600             :             CASE DEFAULT
     601             :                CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
     602             :                                      work, nl_a, nl_b, nl_c, nl_d, &
     603             :                                      sphi_a, &
     604             :                                      sphi_b, &
     605             :                                      sphi_c, &
     606             :                                      sphi_d, &
     607             :                                      primitives, &
     608   238628930 :                                      buffer1, buffer2)
     609             :             END SELECT
     610             :          CASE (1)
     611    46940020 :             SELECT CASE (n_c)
     612             :             CASE (0)
     613    35508713 :                SELECT CASE (n_d)
     614             :                CASE (0)
     615             : #if __MAX_CONTR > 1 || __MAX_CONTR == 1
     616             :                   CALL contract_spss(work, &
     617             :                                      nl_a, nl_b, nl_c, nl_d, &
     618             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
     619             :                                      primitives, &
     620    10876624 :                                      buffer1, buffer2)
     621             : #else
     622             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
     623             :                                         work, nl_a, nl_b, nl_c, nl_d, &
     624             :                                         sphi_a, &
     625             :                                         sphi_b, &
     626             :                                         sphi_c, &
     627             :                                         sphi_d, &
     628             :                                         primitives, &
     629             :                                         buffer1, buffer2)
     630             : #endif
     631             :                CASE (1)
     632             : #if __MAX_CONTR > 1 || __MAX_CONTR == 1
     633             :                   CALL contract_spsp(work, &
     634             :                                      nl_a, nl_b, nl_c, nl_d, &
     635             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
     636             :                                      primitives, &
     637     3975439 :                                      buffer1, buffer2)
     638             : #else
     639             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
     640             :                                         work, nl_a, nl_b, nl_c, nl_d, &
     641             :                                         sphi_a, &
     642             :                                         sphi_b, &
     643             :                                         sphi_c, &
     644             :                                         sphi_d, &
     645             :                                         primitives, &
     646             :                                         buffer1, buffer2)
     647             : #endif
     648             :                CASE (2)
     649             : #if __MAX_CONTR > 2 || __MAX_CONTR == 2
     650             :                   CALL contract_spsd(work, &
     651             :                                      nl_a, nl_b, nl_c, nl_d, &
     652             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
     653             :                                      primitives, &
     654      975805 :                                      buffer1, buffer2)
     655             : #else
     656             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
     657             :                                         work, nl_a, nl_b, nl_c, nl_d, &
     658             :                                         sphi_a, &
     659             :                                         sphi_b, &
     660             :                                         sphi_c, &
     661             :                                         sphi_d, &
     662             :                                         primitives, &
     663             :                                         buffer1, buffer2)
     664             : #endif
     665             :                CASE (3)
     666             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
     667             :                   CALL contract_spsf(work, &
     668             :                                      nl_a, nl_b, nl_c, nl_d, &
     669             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
     670             :                                      primitives, &
     671             :                                      buffer1, buffer2)
     672             : #else
     673             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
     674             :                                         work, nl_a, nl_b, nl_c, nl_d, &
     675             :                                         sphi_a, &
     676             :                                         sphi_b, &
     677             :                                         sphi_c, &
     678             :                                         sphi_d, &
     679             :                                         primitives, &
     680       18669 :                                         buffer1, buffer2)
     681             : #endif
     682             :                CASE (4)
     683             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
     684             :                   CALL contract_spsg(work, &
     685             :                                      nl_a, nl_b, nl_c, nl_d, &
     686             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
     687             :                                      primitives, &
     688             :                                      buffer1, buffer2)
     689             : #else
     690             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
     691             :                                         work, nl_a, nl_b, nl_c, nl_d, &
     692             :                                         sphi_a, &
     693             :                                         sphi_b, &
     694             :                                         sphi_c, &
     695             :                                         sphi_d, &
     696             :                                         primitives, &
     697           0 :                                         buffer1, buffer2)
     698             : #endif
     699             :                CASE DEFAULT
     700             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
     701             :                                         work, nl_a, nl_b, nl_c, nl_d, &
     702             :                                         sphi_a, &
     703             :                                         sphi_b, &
     704             :                                         sphi_c, &
     705             :                                         sphi_d, &
     706             :                                         primitives, &
     707    15846537 :                                         buffer1, buffer2)
     708             :                END SELECT
     709             :             CASE (1)
     710    14808179 :                SELECT CASE (n_d)
     711             :                CASE (0)
     712             : #if __MAX_CONTR > 1 || __MAX_CONTR == 1
     713             :                   CALL contract_spps(work, &
     714             :                                      nl_a, nl_b, nl_c, nl_d, &
     715             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
     716             :                                      primitives, &
     717     4134203 :                                      buffer1, buffer2)
     718             : #else
     719             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
     720             :                                         work, nl_a, nl_b, nl_c, nl_d, &
     721             :                                         sphi_a, &
     722             :                                         sphi_b, &
     723             :                                         sphi_c, &
     724             :                                         sphi_d, &
     725             :                                         primitives, &
     726             :                                         buffer1, buffer2)
     727             : #endif
     728             :                CASE (1)
     729             : #if __MAX_CONTR > 1 || __MAX_CONTR == 1
     730             :                   CALL contract_sppp(work, &
     731             :                                      nl_a, nl_b, nl_c, nl_d, &
     732             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
     733             :                                      primitives, &
     734     4103561 :                                      buffer1, buffer2)
     735             : #else
     736             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
     737             :                                         work, nl_a, nl_b, nl_c, nl_d, &
     738             :                                         sphi_a, &
     739             :                                         sphi_b, &
     740             :                                         sphi_c, &
     741             :                                         sphi_d, &
     742             :                                         primitives, &
     743             :                                         buffer1, buffer2)
     744             : #endif
     745             :                CASE (2)
     746             : #if __MAX_CONTR > 2 || __MAX_CONTR == 2
     747             :                   CALL contract_sppd(work, &
     748             :                                      nl_a, nl_b, nl_c, nl_d, &
     749             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
     750             :                                      primitives, &
     751      540768 :                                      buffer1, buffer2)
     752             : #else
     753             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
     754             :                                         work, nl_a, nl_b, nl_c, nl_d, &
     755             :                                         sphi_a, &
     756             :                                         sphi_b, &
     757             :                                         sphi_c, &
     758             :                                         sphi_d, &
     759             :                                         primitives, &
     760             :                                         buffer1, buffer2)
     761             : #endif
     762             :                CASE (3)
     763             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
     764             :                   CALL contract_sppf(work, &
     765             :                                      nl_a, nl_b, nl_c, nl_d, &
     766             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
     767             :                                      primitives, &
     768             :                                      buffer1, buffer2)
     769             : #else
     770             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
     771             :                                         work, nl_a, nl_b, nl_c, nl_d, &
     772             :                                         sphi_a, &
     773             :                                         sphi_b, &
     774             :                                         sphi_c, &
     775             :                                         sphi_d, &
     776             :                                         primitives, &
     777        7020 :                                         buffer1, buffer2)
     778             : #endif
     779             :                CASE (4)
     780             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
     781             :                   CALL contract_sppg(work, &
     782             :                                      nl_a, nl_b, nl_c, nl_d, &
     783             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
     784             :                                      primitives, &
     785             :                                      buffer1, buffer2)
     786             : #else
     787             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
     788             :                                         work, nl_a, nl_b, nl_c, nl_d, &
     789             :                                         sphi_a, &
     790             :                                         sphi_b, &
     791             :                                         sphi_c, &
     792             :                                         sphi_d, &
     793             :                                         primitives, &
     794           0 :                                         buffer1, buffer2)
     795             : #endif
     796             :                CASE DEFAULT
     797             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
     798             :                                         work, nl_a, nl_b, nl_c, nl_d, &
     799             :                                         sphi_a, &
     800             :                                         sphi_b, &
     801             :                                         sphi_c, &
     802             :                                         sphi_d, &
     803             :                                         primitives, &
     804     8785552 :                                         buffer1, buffer2)
     805             :                END SELECT
     806             :             CASE (2)
     807     3020321 :                SELECT CASE (n_d)
     808             :                CASE (0)
     809             : #if __MAX_CONTR > 2 || __MAX_CONTR == 2
     810             :                   CALL contract_spds(work, &
     811             :                                      nl_a, nl_b, nl_c, nl_d, &
     812             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
     813             :                                      primitives, &
     814     1106505 :                                      buffer1, buffer2)
     815             : #else
     816             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
     817             :                                         work, nl_a, nl_b, nl_c, nl_d, &
     818             :                                         sphi_a, &
     819             :                                         sphi_b, &
     820             :                                         sphi_c, &
     821             :                                         sphi_d, &
     822             :                                         primitives, &
     823             :                                         buffer1, buffer2)
     824             : #endif
     825             :                CASE (1)
     826             : #if __MAX_CONTR > 2 || __MAX_CONTR == 2
     827             :                   CALL contract_spdp(work, &
     828             :                                      nl_a, nl_b, nl_c, nl_d, &
     829             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
     830             :                                      primitives, &
     831      529786 :                                      buffer1, buffer2)
     832             : #else
     833             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
     834             :                                         work, nl_a, nl_b, nl_c, nl_d, &
     835             :                                         sphi_a, &
     836             :                                         sphi_b, &
     837             :                                         sphi_c, &
     838             :                                         sphi_d, &
     839             :                                         primitives, &
     840             :                                         buffer1, buffer2)
     841             : #endif
     842             :                CASE (2)
     843             : #if __MAX_CONTR > 2 || __MAX_CONTR == 2
     844             :                   CALL contract_spdd(work, &
     845             :                                      nl_a, nl_b, nl_c, nl_d, &
     846             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
     847             :                                      primitives, &
     848      245099 :                                      buffer1, buffer2)
     849             : #else
     850             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
     851             :                                         work, nl_a, nl_b, nl_c, nl_d, &
     852             :                                         sphi_a, &
     853             :                                         sphi_b, &
     854             :                                         sphi_c, &
     855             :                                         sphi_d, &
     856             :                                         primitives, &
     857             :                                         buffer1, buffer2)
     858             : #endif
     859             :                CASE (3)
     860             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
     861             :                   CALL contract_spdf(work, &
     862             :                                      nl_a, nl_b, nl_c, nl_d, &
     863             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
     864             :                                      primitives, &
     865             :                                      buffer1, buffer2)
     866             : #else
     867             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
     868             :                                         work, nl_a, nl_b, nl_c, nl_d, &
     869             :                                         sphi_a, &
     870             :                                         sphi_b, &
     871             :                                         sphi_c, &
     872             :                                         sphi_d, &
     873             :                                         primitives, &
     874        7034 :                                         buffer1, buffer2)
     875             : #endif
     876             :                CASE (4)
     877             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
     878             :                   CALL contract_spdg(work, &
     879             :                                      nl_a, nl_b, nl_c, nl_d, &
     880             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
     881             :                                      primitives, &
     882             :                                      buffer1, buffer2)
     883             : #else
     884             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
     885             :                                         work, nl_a, nl_b, nl_c, nl_d, &
     886             :                                         sphi_a, &
     887             :                                         sphi_b, &
     888             :                                         sphi_c, &
     889             :                                         sphi_d, &
     890             :                                         primitives, &
     891           0 :                                         buffer1, buffer2)
     892             : #endif
     893             :                CASE DEFAULT
     894             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
     895             :                                         work, nl_a, nl_b, nl_c, nl_d, &
     896             :                                         sphi_a, &
     897             :                                         sphi_b, &
     898             :                                         sphi_c, &
     899             :                                         sphi_d, &
     900             :                                         primitives, &
     901     1888424 :                                         buffer1, buffer2)
     902             :                END SELECT
     903             :             CASE (3)
     904       39330 :                SELECT CASE (n_d)
     905             :                CASE (0)
     906             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
     907             :                   CALL contract_spfs(work, &
     908             :                                      nl_a, nl_b, nl_c, nl_d, &
     909             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
     910             :                                      primitives, &
     911             :                                      buffer1, buffer2)
     912             : #else
     913             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
     914             :                                         work, nl_a, nl_b, nl_c, nl_d, &
     915             :                                         sphi_a, &
     916             :                                         sphi_b, &
     917             :                                         sphi_c, &
     918             :                                         sphi_d, &
     919             :                                         primitives, &
     920       13938 :                                         buffer1, buffer2)
     921             : #endif
     922             :                CASE (1)
     923             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
     924             :                   CALL contract_spfp(work, &
     925             :                                      nl_a, nl_b, nl_c, nl_d, &
     926             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
     927             :                                      primitives, &
     928             :                                      buffer1, buffer2)
     929             : #else
     930             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
     931             :                                         work, nl_a, nl_b, nl_c, nl_d, &
     932             :                                         sphi_a, &
     933             :                                         sphi_b, &
     934             :                                         sphi_c, &
     935             :                                         sphi_d, &
     936             :                                         primitives, &
     937        5298 :                                         buffer1, buffer2)
     938             : #endif
     939             :                CASE (2)
     940             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
     941             :                   CALL contract_spfd(work, &
     942             :                                      nl_a, nl_b, nl_c, nl_d, &
     943             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
     944             :                                      primitives, &
     945             :                                      buffer1, buffer2)
     946             : #else
     947             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
     948             :                                         work, nl_a, nl_b, nl_c, nl_d, &
     949             :                                         sphi_a, &
     950             :                                         sphi_b, &
     951             :                                         sphi_c, &
     952             :                                         sphi_d, &
     953             :                                         primitives, &
     954        4234 :                                         buffer1, buffer2)
     955             : #endif
     956             :                CASE (3)
     957             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
     958             :                   CALL contract_spff(work, &
     959             :                                      nl_a, nl_b, nl_c, nl_d, &
     960             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
     961             :                                      primitives, &
     962             :                                      buffer1, buffer2)
     963             : #else
     964             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
     965             :                                         work, nl_a, nl_b, nl_c, nl_d, &
     966             :                                         sphi_a, &
     967             :                                         sphi_b, &
     968             :                                         sphi_c, &
     969             :                                         sphi_d, &
     970             :                                         primitives, &
     971        1922 :                                         buffer1, buffer2)
     972             : #endif
     973             :                CASE (4)
     974             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
     975             :                   CALL contract_spfg(work, &
     976             :                                      nl_a, nl_b, nl_c, nl_d, &
     977             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
     978             :                                      primitives, &
     979             :                                      buffer1, buffer2)
     980             : #else
     981             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
     982             :                                         work, nl_a, nl_b, nl_c, nl_d, &
     983             :                                         sphi_a, &
     984             :                                         sphi_b, &
     985             :                                         sphi_c, &
     986             :                                         sphi_d, &
     987             :                                         primitives, &
     988           0 :                                         buffer1, buffer2)
     989             : #endif
     990             :                CASE DEFAULT
     991             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
     992             :                                         work, nl_a, nl_b, nl_c, nl_d, &
     993             :                                         sphi_a, &
     994             :                                         sphi_b, &
     995             :                                         sphi_c, &
     996             :                                         sphi_d, &
     997             :                                         primitives, &
     998       25392 :                                         buffer1, buffer2)
     999             :                END SELECT
    1000             :             CASE (4)
    1001           0 :                SELECT CASE (n_d)
    1002             :                CASE (0)
    1003             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    1004             :                   CALL contract_spgs(work, &
    1005             :                                      nl_a, nl_b, nl_c, nl_d, &
    1006             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    1007             :                                      primitives, &
    1008             :                                      buffer1, buffer2)
    1009             : #else
    1010             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    1011             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    1012             :                                         sphi_a, &
    1013             :                                         sphi_b, &
    1014             :                                         sphi_c, &
    1015             :                                         sphi_d, &
    1016             :                                         primitives, &
    1017           0 :                                         buffer1, buffer2)
    1018             : #endif
    1019             :                CASE (1)
    1020             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    1021             :                   CALL contract_spgp(work, &
    1022             :                                      nl_a, nl_b, nl_c, nl_d, &
    1023             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    1024             :                                      primitives, &
    1025             :                                      buffer1, buffer2)
    1026             : #else
    1027             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    1028             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    1029             :                                         sphi_a, &
    1030             :                                         sphi_b, &
    1031             :                                         sphi_c, &
    1032             :                                         sphi_d, &
    1033             :                                         primitives, &
    1034           0 :                                         buffer1, buffer2)
    1035             : #endif
    1036             :                CASE (2)
    1037             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    1038             :                   CALL contract_spgd(work, &
    1039             :                                      nl_a, nl_b, nl_c, nl_d, &
    1040             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    1041             :                                      primitives, &
    1042             :                                      buffer1, buffer2)
    1043             : #else
    1044             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    1045             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    1046             :                                         sphi_a, &
    1047             :                                         sphi_b, &
    1048             :                                         sphi_c, &
    1049             :                                         sphi_d, &
    1050             :                                         primitives, &
    1051           0 :                                         buffer1, buffer2)
    1052             : #endif
    1053             :                CASE (3)
    1054             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    1055             :                   CALL contract_spgf(work, &
    1056             :                                      nl_a, nl_b, nl_c, nl_d, &
    1057             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    1058             :                                      primitives, &
    1059             :                                      buffer1, buffer2)
    1060             : #else
    1061             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    1062             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    1063             :                                         sphi_a, &
    1064             :                                         sphi_b, &
    1065             :                                         sphi_c, &
    1066             :                                         sphi_d, &
    1067             :                                         primitives, &
    1068           0 :                                         buffer1, buffer2)
    1069             : #endif
    1070             :                CASE (4)
    1071             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    1072             :                   CALL contract_spgg(work, &
    1073             :                                      nl_a, nl_b, nl_c, nl_d, &
    1074             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    1075             :                                      primitives, &
    1076             :                                      buffer1, buffer2)
    1077             : #else
    1078             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    1079             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    1080             :                                         sphi_a, &
    1081             :                                         sphi_b, &
    1082             :                                         sphi_c, &
    1083             :                                         sphi_d, &
    1084             :                                         primitives, &
    1085           0 :                                         buffer1, buffer2)
    1086             : #endif
    1087             :                CASE DEFAULT
    1088             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    1089             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    1090             :                                         sphi_a, &
    1091             :                                         sphi_b, &
    1092             :                                         sphi_c, &
    1093             :                                         sphi_d, &
    1094             :                                         primitives, &
    1095           0 :                                         buffer1, buffer2)
    1096             :                END SELECT
    1097             :             CASE DEFAULT
    1098             :                CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    1099             :                                      work, nl_a, nl_b, nl_c, nl_d, &
    1100             :                                      sphi_a, &
    1101             :                                      sphi_b, &
    1102             :                                      sphi_c, &
    1103             :                                      sphi_d, &
    1104             :                                      primitives, &
    1105    26545905 :                                      buffer1, buffer2)
    1106             :             END SELECT
    1107             :          CASE (2)
    1108     7137205 :             SELECT CASE (n_c)
    1109             :             CASE (0)
    1110     5256016 :                SELECT CASE (n_d)
    1111             :                CASE (0)
    1112             : #if __MAX_CONTR > 2 || __MAX_CONTR == 2
    1113             :                   CALL contract_sdss(work, &
    1114             :                                      nl_a, nl_b, nl_c, nl_d, &
    1115             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    1116             :                                      primitives, &
    1117     1220780 :                                      buffer1, buffer2)
    1118             : #else
    1119             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    1120             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    1121             :                                         sphi_a, &
    1122             :                                         sphi_b, &
    1123             :                                         sphi_c, &
    1124             :                                         sphi_d, &
    1125             :                                         primitives, &
    1126             :                                         buffer1, buffer2)
    1127             : #endif
    1128             :                CASE (1)
    1129             : #if __MAX_CONTR > 2 || __MAX_CONTR == 2
    1130             :                   CALL contract_sdsp(work, &
    1131             :                                      nl_a, nl_b, nl_c, nl_d, &
    1132             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    1133             :                                      primitives, &
    1134      933455 :                                      buffer1, buffer2)
    1135             : #else
    1136             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    1137             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    1138             :                                         sphi_a, &
    1139             :                                         sphi_b, &
    1140             :                                         sphi_c, &
    1141             :                                         sphi_d, &
    1142             :                                         primitives, &
    1143             :                                         buffer1, buffer2)
    1144             : #endif
    1145             :                CASE (2)
    1146             : #if __MAX_CONTR > 2 || __MAX_CONTR == 2
    1147             :                   CALL contract_sdsd(work, &
    1148             :                                      nl_a, nl_b, nl_c, nl_d, &
    1149             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    1150             :                                      primitives, &
    1151      368566 :                                      buffer1, buffer2)
    1152             : #else
    1153             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    1154             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    1155             :                                         sphi_a, &
    1156             :                                         sphi_b, &
    1157             :                                         sphi_c, &
    1158             :                                         sphi_d, &
    1159             :                                         primitives, &
    1160             :                                         buffer1, buffer2)
    1161             : #endif
    1162             :                CASE (3)
    1163             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    1164             :                   CALL contract_sdsf(work, &
    1165             :                                      nl_a, nl_b, nl_c, nl_d, &
    1166             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    1167             :                                      primitives, &
    1168             :                                      buffer1, buffer2)
    1169             : #else
    1170             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    1171             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    1172             :                                         sphi_a, &
    1173             :                                         sphi_b, &
    1174             :                                         sphi_c, &
    1175             :                                         sphi_d, &
    1176             :                                         primitives, &
    1177        2969 :                                         buffer1, buffer2)
    1178             : #endif
    1179             :                CASE (4)
    1180             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    1181             :                   CALL contract_sdsg(work, &
    1182             :                                      nl_a, nl_b, nl_c, nl_d, &
    1183             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    1184             :                                      primitives, &
    1185             :                                      buffer1, buffer2)
    1186             : #else
    1187             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    1188             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    1189             :                                         sphi_a, &
    1190             :                                         sphi_b, &
    1191             :                                         sphi_c, &
    1192             :                                         sphi_d, &
    1193             :                                         primitives, &
    1194           0 :                                         buffer1, buffer2)
    1195             : #endif
    1196             :                CASE DEFAULT
    1197             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    1198             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    1199             :                                         sphi_a, &
    1200             :                                         sphi_b, &
    1201             :                                         sphi_c, &
    1202             :                                         sphi_d, &
    1203             :                                         primitives, &
    1204     2525770 :                                         buffer1, buffer2)
    1205             :                END SELECT
    1206             :             CASE (1)
    1207     2787820 :                SELECT CASE (n_d)
    1208             :                CASE (0)
    1209             : #if __MAX_CONTR > 2 || __MAX_CONTR == 2
    1210             :                   CALL contract_sdps(work, &
    1211             :                                      nl_a, nl_b, nl_c, nl_d, &
    1212             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    1213             :                                      primitives, &
    1214      773820 :                                      buffer1, buffer2)
    1215             : #else
    1216             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    1217             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    1218             :                                         sphi_a, &
    1219             :                                         sphi_b, &
    1220             :                                         sphi_c, &
    1221             :                                         sphi_d, &
    1222             :                                         primitives, &
    1223             :                                         buffer1, buffer2)
    1224             : #endif
    1225             :                CASE (1)
    1226             : #if __MAX_CONTR > 2 || __MAX_CONTR == 2
    1227             :                   CALL contract_sdpp(work, &
    1228             :                                      nl_a, nl_b, nl_c, nl_d, &
    1229             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    1230             :                                      primitives, &
    1231      457976 :                                      buffer1, buffer2)
    1232             : #else
    1233             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    1234             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    1235             :                                         sphi_a, &
    1236             :                                         sphi_b, &
    1237             :                                         sphi_c, &
    1238             :                                         sphi_d, &
    1239             :                                         primitives, &
    1240             :                                         buffer1, buffer2)
    1241             : #endif
    1242             :                CASE (2)
    1243             : #if __MAX_CONTR > 2 || __MAX_CONTR == 2
    1244             :                   CALL contract_sdpd(work, &
    1245             :                                      nl_a, nl_b, nl_c, nl_d, &
    1246             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    1247             :                                      primitives, &
    1248      271345 :                                      buffer1, buffer2)
    1249             : #else
    1250             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    1251             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    1252             :                                         sphi_a, &
    1253             :                                         sphi_b, &
    1254             :                                         sphi_c, &
    1255             :                                         sphi_d, &
    1256             :                                         primitives, &
    1257             :                                         buffer1, buffer2)
    1258             : #endif
    1259             :                CASE (3)
    1260             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    1261             :                   CALL contract_sdpf(work, &
    1262             :                                      nl_a, nl_b, nl_c, nl_d, &
    1263             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    1264             :                                      primitives, &
    1265             :                                      buffer1, buffer2)
    1266             : #else
    1267             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    1268             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    1269             :                                         sphi_a, &
    1270             :                                         sphi_b, &
    1271             :                                         sphi_c, &
    1272             :                                         sphi_d, &
    1273             :                                         primitives, &
    1274        6325 :                                         buffer1, buffer2)
    1275             : #endif
    1276             :                CASE (4)
    1277             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    1278             :                   CALL contract_sdpg(work, &
    1279             :                                      nl_a, nl_b, nl_c, nl_d, &
    1280             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    1281             :                                      primitives, &
    1282             :                                      buffer1, buffer2)
    1283             : #else
    1284             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    1285             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    1286             :                                         sphi_a, &
    1287             :                                         sphi_b, &
    1288             :                                         sphi_c, &
    1289             :                                         sphi_d, &
    1290             :                                         primitives, &
    1291           0 :                                         buffer1, buffer2)
    1292             : #endif
    1293             :                CASE DEFAULT
    1294             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    1295             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    1296             :                                         sphi_a, &
    1297             :                                         sphi_b, &
    1298             :                                         sphi_c, &
    1299             :                                         sphi_d, &
    1300             :                                         primitives, &
    1301     1509466 :                                         buffer1, buffer2)
    1302             :                END SELECT
    1303             :             CASE (2)
    1304      714014 :                SELECT CASE (n_d)
    1305             :                CASE (0)
    1306             : #if __MAX_CONTR > 2 || __MAX_CONTR == 2
    1307             :                   CALL contract_sdds(work, &
    1308             :                                      nl_a, nl_b, nl_c, nl_d, &
    1309             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    1310             :                                      primitives, &
    1311      201672 :                                      buffer1, buffer2)
    1312             : #else
    1313             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    1314             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    1315             :                                         sphi_a, &
    1316             :                                         sphi_b, &
    1317             :                                         sphi_c, &
    1318             :                                         sphi_d, &
    1319             :                                         primitives, &
    1320             :                                         buffer1, buffer2)
    1321             : #endif
    1322             :                CASE (1)
    1323             : #if __MAX_CONTR > 2 || __MAX_CONTR == 2
    1324             :                   CALL contract_sddp(work, &
    1325             :                                      nl_a, nl_b, nl_c, nl_d, &
    1326             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    1327             :                                      primitives, &
    1328      184955 :                                      buffer1, buffer2)
    1329             : #else
    1330             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    1331             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    1332             :                                         sphi_a, &
    1333             :                                         sphi_b, &
    1334             :                                         sphi_c, &
    1335             :                                         sphi_d, &
    1336             :                                         primitives, &
    1337             :                                         buffer1, buffer2)
    1338             : #endif
    1339             :                CASE (2)
    1340             : #if __MAX_CONTR > 2 || __MAX_CONTR == 2
    1341             :                   CALL contract_sddd(work, &
    1342             :                                      nl_a, nl_b, nl_c, nl_d, &
    1343             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    1344             :                                      primitives, &
    1345      116452 :                                      buffer1, buffer2)
    1346             : #else
    1347             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    1348             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    1349             :                                         sphi_a, &
    1350             :                                         sphi_b, &
    1351             :                                         sphi_c, &
    1352             :                                         sphi_d, &
    1353             :                                         primitives, &
    1354             :                                         buffer1, buffer2)
    1355             : #endif
    1356             :                CASE (3)
    1357             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    1358             :                   CALL contract_sddf(work, &
    1359             :                                      nl_a, nl_b, nl_c, nl_d, &
    1360             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    1361             :                                      primitives, &
    1362             :                                      buffer1, buffer2)
    1363             : #else
    1364             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    1365             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    1366             :                                         sphi_a, &
    1367             :                                         sphi_b, &
    1368             :                                         sphi_c, &
    1369             :                                         sphi_d, &
    1370             :                                         primitives, &
    1371        1455 :                                         buffer1, buffer2)
    1372             : #endif
    1373             :                CASE (4)
    1374             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    1375             :                   CALL contract_sddg(work, &
    1376             :                                      nl_a, nl_b, nl_c, nl_d, &
    1377             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    1378             :                                      primitives, &
    1379             :                                      buffer1, buffer2)
    1380             : #else
    1381             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    1382             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    1383             :                                         sphi_a, &
    1384             :                                         sphi_b, &
    1385             :                                         sphi_c, &
    1386             :                                         sphi_d, &
    1387             :                                         primitives, &
    1388           0 :                                         buffer1, buffer2)
    1389             : #endif
    1390             :                CASE DEFAULT
    1391             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    1392             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    1393             :                                         sphi_a, &
    1394             :                                         sphi_b, &
    1395             :                                         sphi_c, &
    1396             :                                         sphi_d, &
    1397             :                                         primitives, &
    1398      504534 :                                         buffer1, buffer2)
    1399             :                END SELECT
    1400             :             CASE (3)
    1401        9476 :                SELECT CASE (n_d)
    1402             :                CASE (0)
    1403             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    1404             :                   CALL contract_sdfs(work, &
    1405             :                                      nl_a, nl_b, nl_c, nl_d, &
    1406             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    1407             :                                      primitives, &
    1408             :                                      buffer1, buffer2)
    1409             : #else
    1410             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    1411             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    1412             :                                         sphi_a, &
    1413             :                                         sphi_b, &
    1414             :                                         sphi_c, &
    1415             :                                         sphi_d, &
    1416             :                                         primitives, &
    1417        1668 :                                         buffer1, buffer2)
    1418             : #endif
    1419             :                CASE (1)
    1420             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    1421             :                   CALL contract_sdfp(work, &
    1422             :                                      nl_a, nl_b, nl_c, nl_d, &
    1423             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    1424             :                                      primitives, &
    1425             :                                      buffer1, buffer2)
    1426             : #else
    1427             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    1428             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    1429             :                                         sphi_a, &
    1430             :                                         sphi_b, &
    1431             :                                         sphi_c, &
    1432             :                                         sphi_d, &
    1433             :                                         primitives, &
    1434        3437 :                                         buffer1, buffer2)
    1435             : #endif
    1436             :                CASE (2)
    1437             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    1438             :                   CALL contract_sdfd(work, &
    1439             :                                      nl_a, nl_b, nl_c, nl_d, &
    1440             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    1441             :                                      primitives, &
    1442             :                                      buffer1, buffer2)
    1443             : #else
    1444             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    1445             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    1446             :                                         sphi_a, &
    1447             :                                         sphi_b, &
    1448             :                                         sphi_c, &
    1449             :                                         sphi_d, &
    1450             :                                         primitives, &
    1451         912 :                                         buffer1, buffer2)
    1452             : #endif
    1453             :                CASE (3)
    1454             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    1455             :                   CALL contract_sdff(work, &
    1456             :                                      nl_a, nl_b, nl_c, nl_d, &
    1457             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    1458             :                                      primitives, &
    1459             :                                      buffer1, buffer2)
    1460             : #else
    1461             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    1462             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    1463             :                                         sphi_a, &
    1464             :                                         sphi_b, &
    1465             :                                         sphi_c, &
    1466             :                                         sphi_d, &
    1467             :                                         primitives, &
    1468        1791 :                                         buffer1, buffer2)
    1469             : #endif
    1470             :                CASE (4)
    1471             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    1472             :                   CALL contract_sdfg(work, &
    1473             :                                      nl_a, nl_b, nl_c, nl_d, &
    1474             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    1475             :                                      primitives, &
    1476             :                                      buffer1, buffer2)
    1477             : #else
    1478             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    1479             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    1480             :                                         sphi_a, &
    1481             :                                         sphi_b, &
    1482             :                                         sphi_c, &
    1483             :                                         sphi_d, &
    1484             :                                         primitives, &
    1485           0 :                                         buffer1, buffer2)
    1486             : #endif
    1487             :                CASE DEFAULT
    1488             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    1489             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    1490             :                                         sphi_a, &
    1491             :                                         sphi_b, &
    1492             :                                         sphi_c, &
    1493             :                                         sphi_d, &
    1494             :                                         primitives, &
    1495        7808 :                                         buffer1, buffer2)
    1496             :                END SELECT
    1497             :             CASE (4)
    1498           0 :                SELECT CASE (n_d)
    1499             :                CASE (0)
    1500             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    1501             :                   CALL contract_sdgs(work, &
    1502             :                                      nl_a, nl_b, nl_c, nl_d, &
    1503             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    1504             :                                      primitives, &
    1505             :                                      buffer1, buffer2)
    1506             : #else
    1507             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    1508             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    1509             :                                         sphi_a, &
    1510             :                                         sphi_b, &
    1511             :                                         sphi_c, &
    1512             :                                         sphi_d, &
    1513             :                                         primitives, &
    1514           0 :                                         buffer1, buffer2)
    1515             : #endif
    1516             :                CASE (1)
    1517             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    1518             :                   CALL contract_sdgp(work, &
    1519             :                                      nl_a, nl_b, nl_c, nl_d, &
    1520             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    1521             :                                      primitives, &
    1522             :                                      buffer1, buffer2)
    1523             : #else
    1524             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    1525             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    1526             :                                         sphi_a, &
    1527             :                                         sphi_b, &
    1528             :                                         sphi_c, &
    1529             :                                         sphi_d, &
    1530             :                                         primitives, &
    1531           0 :                                         buffer1, buffer2)
    1532             : #endif
    1533             :                CASE (2)
    1534             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    1535             :                   CALL contract_sdgd(work, &
    1536             :                                      nl_a, nl_b, nl_c, nl_d, &
    1537             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    1538             :                                      primitives, &
    1539             :                                      buffer1, buffer2)
    1540             : #else
    1541             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    1542             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    1543             :                                         sphi_a, &
    1544             :                                         sphi_b, &
    1545             :                                         sphi_c, &
    1546             :                                         sphi_d, &
    1547             :                                         primitives, &
    1548           0 :                                         buffer1, buffer2)
    1549             : #endif
    1550             :                CASE (3)
    1551             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    1552             :                   CALL contract_sdgf(work, &
    1553             :                                      nl_a, nl_b, nl_c, nl_d, &
    1554             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    1555             :                                      primitives, &
    1556             :                                      buffer1, buffer2)
    1557             : #else
    1558             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    1559             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    1560             :                                         sphi_a, &
    1561             :                                         sphi_b, &
    1562             :                                         sphi_c, &
    1563             :                                         sphi_d, &
    1564             :                                         primitives, &
    1565           0 :                                         buffer1, buffer2)
    1566             : #endif
    1567             :                CASE (4)
    1568             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    1569             :                   CALL contract_sdgg(work, &
    1570             :                                      nl_a, nl_b, nl_c, nl_d, &
    1571             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    1572             :                                      primitives, &
    1573             :                                      buffer1, buffer2)
    1574             : #else
    1575             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    1576             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    1577             :                                         sphi_a, &
    1578             :                                         sphi_b, &
    1579             :                                         sphi_c, &
    1580             :                                         sphi_d, &
    1581             :                                         primitives, &
    1582           0 :                                         buffer1, buffer2)
    1583             : #endif
    1584             :                CASE DEFAULT
    1585             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    1586             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    1587             :                                         sphi_a, &
    1588             :                                         sphi_b, &
    1589             :                                         sphi_c, &
    1590             :                                         sphi_d, &
    1591             :                                         primitives, &
    1592           0 :                                         buffer1, buffer2)
    1593             :                END SELECT
    1594             :             CASE DEFAULT
    1595             :                CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    1596             :                                      work, nl_a, nl_b, nl_c, nl_d, &
    1597             :                                      sphi_a, &
    1598             :                                      sphi_b, &
    1599             :                                      sphi_c, &
    1600             :                                      sphi_d, &
    1601             :                                      primitives, &
    1602     4547578 :                                      buffer1, buffer2)
    1603             :             END SELECT
    1604             :          CASE (3)
    1605       96695 :             SELECT CASE (n_c)
    1606             :             CASE (0)
    1607       62493 :                SELECT CASE (n_d)
    1608             :                CASE (0)
    1609             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    1610             :                   CALL contract_sfss(work, &
    1611             :                                      nl_a, nl_b, nl_c, nl_d, &
    1612             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    1613             :                                      primitives, &
    1614             :                                      buffer1, buffer2)
    1615             : #else
    1616             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    1617             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    1618             :                                         sphi_a, &
    1619             :                                         sphi_b, &
    1620             :                                         sphi_c, &
    1621             :                                         sphi_d, &
    1622             :                                         primitives, &
    1623        9536 :                                         buffer1, buffer2)
    1624             : #endif
    1625             :                CASE (1)
    1626             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    1627             :                   CALL contract_sfsp(work, &
    1628             :                                      nl_a, nl_b, nl_c, nl_d, &
    1629             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    1630             :                                      primitives, &
    1631             :                                      buffer1, buffer2)
    1632             : #else
    1633             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    1634             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    1635             :                                         sphi_a, &
    1636             :                                         sphi_b, &
    1637             :                                         sphi_c, &
    1638             :                                         sphi_d, &
    1639             :                                         primitives, &
    1640       16542 :                                         buffer1, buffer2)
    1641             : #endif
    1642             :                CASE (2)
    1643             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    1644             :                   CALL contract_sfsd(work, &
    1645             :                                      nl_a, nl_b, nl_c, nl_d, &
    1646             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    1647             :                                      primitives, &
    1648             :                                      buffer1, buffer2)
    1649             : #else
    1650             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    1651             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    1652             :                                         sphi_a, &
    1653             :                                         sphi_b, &
    1654             :                                         sphi_c, &
    1655             :                                         sphi_d, &
    1656             :                                         primitives, &
    1657        2841 :                                         buffer1, buffer2)
    1658             : #endif
    1659             :                CASE (3)
    1660             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    1661             :                   CALL contract_sfsf(work, &
    1662             :                                      nl_a, nl_b, nl_c, nl_d, &
    1663             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    1664             :                                      primitives, &
    1665             :                                      buffer1, buffer2)
    1666             : #else
    1667             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    1668             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    1669             :                                         sphi_a, &
    1670             :                                         sphi_b, &
    1671             :                                         sphi_c, &
    1672             :                                         sphi_d, &
    1673             :                                         primitives, &
    1674        3919 :                                         buffer1, buffer2)
    1675             : #endif
    1676             :                CASE (4)
    1677             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    1678             :                   CALL contract_sfsg(work, &
    1679             :                                      nl_a, nl_b, nl_c, nl_d, &
    1680             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    1681             :                                      primitives, &
    1682             :                                      buffer1, buffer2)
    1683             : #else
    1684             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    1685             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    1686             :                                         sphi_a, &
    1687             :                                         sphi_b, &
    1688             :                                         sphi_c, &
    1689             :                                         sphi_d, &
    1690             :                                         primitives, &
    1691           0 :                                         buffer1, buffer2)
    1692             : #endif
    1693             :                CASE DEFAULT
    1694             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    1695             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    1696             :                                         sphi_a, &
    1697             :                                         sphi_b, &
    1698             :                                         sphi_c, &
    1699             :                                         sphi_d, &
    1700             :                                         primitives, &
    1701       32838 :                                         buffer1, buffer2)
    1702             :                END SELECT
    1703             :             CASE (1)
    1704       36889 :                SELECT CASE (n_d)
    1705             :                CASE (0)
    1706             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    1707             :                   CALL contract_sfps(work, &
    1708             :                                      nl_a, nl_b, nl_c, nl_d, &
    1709             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    1710             :                                      primitives, &
    1711             :                                      buffer1, buffer2)
    1712             : #else
    1713             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    1714             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    1715             :                                         sphi_a, &
    1716             :                                         sphi_b, &
    1717             :                                         sphi_c, &
    1718             :                                         sphi_d, &
    1719             :                                         primitives, &
    1720        9664 :                                         buffer1, buffer2)
    1721             : #endif
    1722             :                CASE (1)
    1723             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    1724             :                   CALL contract_sfpp(work, &
    1725             :                                      nl_a, nl_b, nl_c, nl_d, &
    1726             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    1727             :                                      primitives, &
    1728             :                                      buffer1, buffer2)
    1729             : #else
    1730             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    1731             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    1732             :                                         sphi_a, &
    1733             :                                         sphi_b, &
    1734             :                                         sphi_c, &
    1735             :                                         sphi_d, &
    1736             :                                         primitives, &
    1737        3738 :                                         buffer1, buffer2)
    1738             : #endif
    1739             :                CASE (2)
    1740             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    1741             :                   CALL contract_sfpd(work, &
    1742             :                                      nl_a, nl_b, nl_c, nl_d, &
    1743             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    1744             :                                      primitives, &
    1745             :                                      buffer1, buffer2)
    1746             : #else
    1747             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    1748             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    1749             :                                         sphi_a, &
    1750             :                                         sphi_b, &
    1751             :                                         sphi_c, &
    1752             :                                         sphi_d, &
    1753             :                                         primitives, &
    1754        5294 :                                         buffer1, buffer2)
    1755             : #endif
    1756             :                CASE (3)
    1757             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    1758             :                   CALL contract_sfpf(work, &
    1759             :                                      nl_a, nl_b, nl_c, nl_d, &
    1760             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    1761             :                                      primitives, &
    1762             :                                      buffer1, buffer2)
    1763             : #else
    1764             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    1765             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    1766             :                                         sphi_a, &
    1767             :                                         sphi_b, &
    1768             :                                         sphi_c, &
    1769             :                                         sphi_d, &
    1770             :                                         primitives, &
    1771        1423 :                                         buffer1, buffer2)
    1772             : #endif
    1773             :                CASE (4)
    1774             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    1775             :                   CALL contract_sfpg(work, &
    1776             :                                      nl_a, nl_b, nl_c, nl_d, &
    1777             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    1778             :                                      primitives, &
    1779             :                                      buffer1, buffer2)
    1780             : #else
    1781             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    1782             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    1783             :                                         sphi_a, &
    1784             :                                         sphi_b, &
    1785             :                                         sphi_c, &
    1786             :                                         sphi_d, &
    1787             :                                         primitives, &
    1788           0 :                                         buffer1, buffer2)
    1789             : #endif
    1790             :                CASE DEFAULT
    1791             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    1792             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    1793             :                                         sphi_a, &
    1794             :                                         sphi_b, &
    1795             :                                         sphi_c, &
    1796             :                                         sphi_d, &
    1797             :                                         primitives, &
    1798       20119 :                                         buffer1, buffer2)
    1799             :                END SELECT
    1800             :             CASE (2)
    1801       12387 :                SELECT CASE (n_d)
    1802             :                CASE (0)
    1803             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    1804             :                   CALL contract_sfds(work, &
    1805             :                                      nl_a, nl_b, nl_c, nl_d, &
    1806             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    1807             :                                      primitives, &
    1808             :                                      buffer1, buffer2)
    1809             : #else
    1810             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    1811             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    1812             :                                         sphi_a, &
    1813             :                                         sphi_b, &
    1814             :                                         sphi_c, &
    1815             :                                         sphi_d, &
    1816             :                                         primitives, &
    1817        1487 :                                         buffer1, buffer2)
    1818             : #endif
    1819             :                CASE (1)
    1820             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    1821             :                   CALL contract_sfdp(work, &
    1822             :                                      nl_a, nl_b, nl_c, nl_d, &
    1823             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    1824             :                                      primitives, &
    1825             :                                      buffer1, buffer2)
    1826             : #else
    1827             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    1828             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    1829             :                                         sphi_a, &
    1830             :                                         sphi_b, &
    1831             :                                         sphi_c, &
    1832             :                                         sphi_d, &
    1833             :                                         primitives, &
    1834        2941 :                                         buffer1, buffer2)
    1835             : #endif
    1836             :                CASE (2)
    1837             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    1838             :                   CALL contract_sfdd(work, &
    1839             :                                      nl_a, nl_b, nl_c, nl_d, &
    1840             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    1841             :                                      primitives, &
    1842             :                                      buffer1, buffer2)
    1843             : #else
    1844             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    1845             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    1846             :                                         sphi_a, &
    1847             :                                         sphi_b, &
    1848             :                                         sphi_c, &
    1849             :                                         sphi_d, &
    1850             :                                         primitives, &
    1851        1109 :                                         buffer1, buffer2)
    1852             : #endif
    1853             :                CASE (3)
    1854             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    1855             :                   CALL contract_sfdf(work, &
    1856             :                                      nl_a, nl_b, nl_c, nl_d, &
    1857             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    1858             :                                      primitives, &
    1859             :                                      buffer1, buffer2)
    1860             : #else
    1861             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    1862             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    1863             :                                         sphi_a, &
    1864             :                                         sphi_b, &
    1865             :                                         sphi_c, &
    1866             :                                         sphi_d, &
    1867             :                                         primitives, &
    1868        1569 :                                         buffer1, buffer2)
    1869             : #endif
    1870             :                CASE (4)
    1871             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    1872             :                   CALL contract_sfdg(work, &
    1873             :                                      nl_a, nl_b, nl_c, nl_d, &
    1874             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    1875             :                                      primitives, &
    1876             :                                      buffer1, buffer2)
    1877             : #else
    1878             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    1879             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    1880             :                                         sphi_a, &
    1881             :                                         sphi_b, &
    1882             :                                         sphi_c, &
    1883             :                                         sphi_d, &
    1884             :                                         primitives, &
    1885           0 :                                         buffer1, buffer2)
    1886             : #endif
    1887             :                CASE DEFAULT
    1888             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    1889             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    1890             :                                         sphi_a, &
    1891             :                                         sphi_b, &
    1892             :                                         sphi_c, &
    1893             :                                         sphi_d, &
    1894             :                                         primitives, &
    1895        7106 :                                         buffer1, buffer2)
    1896             :                END SELECT
    1897             :             CASE (3)
    1898        5562 :                SELECT CASE (n_d)
    1899             :                CASE (0)
    1900             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    1901             :                   CALL contract_sffs(work, &
    1902             :                                      nl_a, nl_b, nl_c, nl_d, &
    1903             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    1904             :                                      primitives, &
    1905             :                                      buffer1, buffer2)
    1906             : #else
    1907             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    1908             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    1909             :                                         sphi_a, &
    1910             :                                         sphi_b, &
    1911             :                                         sphi_c, &
    1912             :                                         sphi_d, &
    1913             :                                         primitives, &
    1914        1768 :                                         buffer1, buffer2)
    1915             : #endif
    1916             :                CASE (1)
    1917             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    1918             :                   CALL contract_sffp(work, &
    1919             :                                      nl_a, nl_b, nl_c, nl_d, &
    1920             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    1921             :                                      primitives, &
    1922             :                                      buffer1, buffer2)
    1923             : #else
    1924             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    1925             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    1926             :                                         sphi_a, &
    1927             :                                         sphi_b, &
    1928             :                                         sphi_c, &
    1929             :                                         sphi_d, &
    1930             :                                         primitives, &
    1931         705 :                                         buffer1, buffer2)
    1932             : #endif
    1933             :                CASE (2)
    1934             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    1935             :                   CALL contract_sffd(work, &
    1936             :                                      nl_a, nl_b, nl_c, nl_d, &
    1937             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    1938             :                                      primitives, &
    1939             :                                      buffer1, buffer2)
    1940             : #else
    1941             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    1942             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    1943             :                                         sphi_a, &
    1944             :                                         sphi_b, &
    1945             :                                         sphi_c, &
    1946             :                                         sphi_d, &
    1947             :                                         primitives, &
    1948         837 :                                         buffer1, buffer2)
    1949             : #endif
    1950             :                CASE (3)
    1951             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    1952             :                   CALL contract_sfff(work, &
    1953             :                                      nl_a, nl_b, nl_c, nl_d, &
    1954             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    1955             :                                      primitives, &
    1956             :                                      buffer1, buffer2)
    1957             : #else
    1958             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    1959             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    1960             :                                         sphi_a, &
    1961             :                                         sphi_b, &
    1962             :                                         sphi_c, &
    1963             :                                         sphi_d, &
    1964             :                                         primitives, &
    1965         484 :                                         buffer1, buffer2)
    1966             : #endif
    1967             :                CASE (4)
    1968             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    1969             :                   CALL contract_sffg(work, &
    1970             :                                      nl_a, nl_b, nl_c, nl_d, &
    1971             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    1972             :                                      primitives, &
    1973             :                                      buffer1, buffer2)
    1974             : #else
    1975             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    1976             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    1977             :                                         sphi_a, &
    1978             :                                         sphi_b, &
    1979             :                                         sphi_c, &
    1980             :                                         sphi_d, &
    1981             :                                         primitives, &
    1982           0 :                                         buffer1, buffer2)
    1983             : #endif
    1984             :                CASE DEFAULT
    1985             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    1986             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    1987             :                                         sphi_a, &
    1988             :                                         sphi_b, &
    1989             :                                         sphi_c, &
    1990             :                                         sphi_d, &
    1991             :                                         primitives, &
    1992        3794 :                                         buffer1, buffer2)
    1993             :                END SELECT
    1994             :             CASE (4)
    1995           0 :                SELECT CASE (n_d)
    1996             :                CASE (0)
    1997             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    1998             :                   CALL contract_sfgs(work, &
    1999             :                                      nl_a, nl_b, nl_c, nl_d, &
    2000             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    2001             :                                      primitives, &
    2002             :                                      buffer1, buffer2)
    2003             : #else
    2004             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    2005             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    2006             :                                         sphi_a, &
    2007             :                                         sphi_b, &
    2008             :                                         sphi_c, &
    2009             :                                         sphi_d, &
    2010             :                                         primitives, &
    2011           0 :                                         buffer1, buffer2)
    2012             : #endif
    2013             :                CASE (1)
    2014             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    2015             :                   CALL contract_sfgp(work, &
    2016             :                                      nl_a, nl_b, nl_c, nl_d, &
    2017             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    2018             :                                      primitives, &
    2019             :                                      buffer1, buffer2)
    2020             : #else
    2021             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    2022             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    2023             :                                         sphi_a, &
    2024             :                                         sphi_b, &
    2025             :                                         sphi_c, &
    2026             :                                         sphi_d, &
    2027             :                                         primitives, &
    2028           0 :                                         buffer1, buffer2)
    2029             : #endif
    2030             :                CASE (2)
    2031             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    2032             :                   CALL contract_sfgd(work, &
    2033             :                                      nl_a, nl_b, nl_c, nl_d, &
    2034             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    2035             :                                      primitives, &
    2036             :                                      buffer1, buffer2)
    2037             : #else
    2038             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    2039             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    2040             :                                         sphi_a, &
    2041             :                                         sphi_b, &
    2042             :                                         sphi_c, &
    2043             :                                         sphi_d, &
    2044             :                                         primitives, &
    2045           0 :                                         buffer1, buffer2)
    2046             : #endif
    2047             :                CASE (3)
    2048             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    2049             :                   CALL contract_sfgf(work, &
    2050             :                                      nl_a, nl_b, nl_c, nl_d, &
    2051             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    2052             :                                      primitives, &
    2053             :                                      buffer1, buffer2)
    2054             : #else
    2055             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    2056             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    2057             :                                         sphi_a, &
    2058             :                                         sphi_b, &
    2059             :                                         sphi_c, &
    2060             :                                         sphi_d, &
    2061             :                                         primitives, &
    2062           0 :                                         buffer1, buffer2)
    2063             : #endif
    2064             :                CASE (4)
    2065             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    2066             :                   CALL contract_sfgg(work, &
    2067             :                                      nl_a, nl_b, nl_c, nl_d, &
    2068             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    2069             :                                      primitives, &
    2070             :                                      buffer1, buffer2)
    2071             : #else
    2072             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    2073             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    2074             :                                         sphi_a, &
    2075             :                                         sphi_b, &
    2076             :                                         sphi_c, &
    2077             :                                         sphi_d, &
    2078             :                                         primitives, &
    2079           0 :                                         buffer1, buffer2)
    2080             : #endif
    2081             :                CASE DEFAULT
    2082             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    2083             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    2084             :                                         sphi_a, &
    2085             :                                         sphi_b, &
    2086             :                                         sphi_c, &
    2087             :                                         sphi_d, &
    2088             :                                         primitives, &
    2089           0 :                                         buffer1, buffer2)
    2090             :                END SELECT
    2091             :             CASE DEFAULT
    2092             :                CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    2093             :                                      work, nl_a, nl_b, nl_c, nl_d, &
    2094             :                                      sphi_a, &
    2095             :                                      sphi_b, &
    2096             :                                      sphi_c, &
    2097             :                                      sphi_d, &
    2098             :                                      primitives, &
    2099       63857 :                                      buffer1, buffer2)
    2100             :             END SELECT
    2101             :          CASE (4)
    2102           0 :             SELECT CASE (n_c)
    2103             :             CASE (0)
    2104           0 :                SELECT CASE (n_d)
    2105             :                CASE (0)
    2106             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    2107             :                   CALL contract_sgss(work, &
    2108             :                                      nl_a, nl_b, nl_c, nl_d, &
    2109             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    2110             :                                      primitives, &
    2111             :                                      buffer1, buffer2)
    2112             : #else
    2113             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    2114             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    2115             :                                         sphi_a, &
    2116             :                                         sphi_b, &
    2117             :                                         sphi_c, &
    2118             :                                         sphi_d, &
    2119             :                                         primitives, &
    2120           0 :                                         buffer1, buffer2)
    2121             : #endif
    2122             :                CASE (1)
    2123             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    2124             :                   CALL contract_sgsp(work, &
    2125             :                                      nl_a, nl_b, nl_c, nl_d, &
    2126             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    2127             :                                      primitives, &
    2128             :                                      buffer1, buffer2)
    2129             : #else
    2130             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    2131             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    2132             :                                         sphi_a, &
    2133             :                                         sphi_b, &
    2134             :                                         sphi_c, &
    2135             :                                         sphi_d, &
    2136             :                                         primitives, &
    2137           0 :                                         buffer1, buffer2)
    2138             : #endif
    2139             :                CASE (2)
    2140             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    2141             :                   CALL contract_sgsd(work, &
    2142             :                                      nl_a, nl_b, nl_c, nl_d, &
    2143             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    2144             :                                      primitives, &
    2145             :                                      buffer1, buffer2)
    2146             : #else
    2147             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    2148             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    2149             :                                         sphi_a, &
    2150             :                                         sphi_b, &
    2151             :                                         sphi_c, &
    2152             :                                         sphi_d, &
    2153             :                                         primitives, &
    2154           0 :                                         buffer1, buffer2)
    2155             : #endif
    2156             :                CASE (3)
    2157             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    2158             :                   CALL contract_sgsf(work, &
    2159             :                                      nl_a, nl_b, nl_c, nl_d, &
    2160             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    2161             :                                      primitives, &
    2162             :                                      buffer1, buffer2)
    2163             : #else
    2164             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    2165             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    2166             :                                         sphi_a, &
    2167             :                                         sphi_b, &
    2168             :                                         sphi_c, &
    2169             :                                         sphi_d, &
    2170             :                                         primitives, &
    2171           0 :                                         buffer1, buffer2)
    2172             : #endif
    2173             :                CASE (4)
    2174             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    2175             :                   CALL contract_sgsg(work, &
    2176             :                                      nl_a, nl_b, nl_c, nl_d, &
    2177             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    2178             :                                      primitives, &
    2179             :                                      buffer1, buffer2)
    2180             : #else
    2181             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    2182             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    2183             :                                         sphi_a, &
    2184             :                                         sphi_b, &
    2185             :                                         sphi_c, &
    2186             :                                         sphi_d, &
    2187             :                                         primitives, &
    2188           0 :                                         buffer1, buffer2)
    2189             : #endif
    2190             :                CASE DEFAULT
    2191             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    2192             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    2193             :                                         sphi_a, &
    2194             :                                         sphi_b, &
    2195             :                                         sphi_c, &
    2196             :                                         sphi_d, &
    2197             :                                         primitives, &
    2198           0 :                                         buffer1, buffer2)
    2199             :                END SELECT
    2200             :             CASE (1)
    2201           0 :                SELECT CASE (n_d)
    2202             :                CASE (0)
    2203             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    2204             :                   CALL contract_sgps(work, &
    2205             :                                      nl_a, nl_b, nl_c, nl_d, &
    2206             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    2207             :                                      primitives, &
    2208             :                                      buffer1, buffer2)
    2209             : #else
    2210             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    2211             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    2212             :                                         sphi_a, &
    2213             :                                         sphi_b, &
    2214             :                                         sphi_c, &
    2215             :                                         sphi_d, &
    2216             :                                         primitives, &
    2217           0 :                                         buffer1, buffer2)
    2218             : #endif
    2219             :                CASE (1)
    2220             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    2221             :                   CALL contract_sgpp(work, &
    2222             :                                      nl_a, nl_b, nl_c, nl_d, &
    2223             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    2224             :                                      primitives, &
    2225             :                                      buffer1, buffer2)
    2226             : #else
    2227             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    2228             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    2229             :                                         sphi_a, &
    2230             :                                         sphi_b, &
    2231             :                                         sphi_c, &
    2232             :                                         sphi_d, &
    2233             :                                         primitives, &
    2234           0 :                                         buffer1, buffer2)
    2235             : #endif
    2236             :                CASE (2)
    2237             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    2238             :                   CALL contract_sgpd(work, &
    2239             :                                      nl_a, nl_b, nl_c, nl_d, &
    2240             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    2241             :                                      primitives, &
    2242             :                                      buffer1, buffer2)
    2243             : #else
    2244             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    2245             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    2246             :                                         sphi_a, &
    2247             :                                         sphi_b, &
    2248             :                                         sphi_c, &
    2249             :                                         sphi_d, &
    2250             :                                         primitives, &
    2251           0 :                                         buffer1, buffer2)
    2252             : #endif
    2253             :                CASE (3)
    2254             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    2255             :                   CALL contract_sgpf(work, &
    2256             :                                      nl_a, nl_b, nl_c, nl_d, &
    2257             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    2258             :                                      primitives, &
    2259             :                                      buffer1, buffer2)
    2260             : #else
    2261             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    2262             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    2263             :                                         sphi_a, &
    2264             :                                         sphi_b, &
    2265             :                                         sphi_c, &
    2266             :                                         sphi_d, &
    2267             :                                         primitives, &
    2268           0 :                                         buffer1, buffer2)
    2269             : #endif
    2270             :                CASE (4)
    2271             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    2272             :                   CALL contract_sgpg(work, &
    2273             :                                      nl_a, nl_b, nl_c, nl_d, &
    2274             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    2275             :                                      primitives, &
    2276             :                                      buffer1, buffer2)
    2277             : #else
    2278             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    2279             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    2280             :                                         sphi_a, &
    2281             :                                         sphi_b, &
    2282             :                                         sphi_c, &
    2283             :                                         sphi_d, &
    2284             :                                         primitives, &
    2285           0 :                                         buffer1, buffer2)
    2286             : #endif
    2287             :                CASE DEFAULT
    2288             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    2289             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    2290             :                                         sphi_a, &
    2291             :                                         sphi_b, &
    2292             :                                         sphi_c, &
    2293             :                                         sphi_d, &
    2294             :                                         primitives, &
    2295           0 :                                         buffer1, buffer2)
    2296             :                END SELECT
    2297             :             CASE (2)
    2298           0 :                SELECT CASE (n_d)
    2299             :                CASE (0)
    2300             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    2301             :                   CALL contract_sgds(work, &
    2302             :                                      nl_a, nl_b, nl_c, nl_d, &
    2303             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    2304             :                                      primitives, &
    2305             :                                      buffer1, buffer2)
    2306             : #else
    2307             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    2308             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    2309             :                                         sphi_a, &
    2310             :                                         sphi_b, &
    2311             :                                         sphi_c, &
    2312             :                                         sphi_d, &
    2313             :                                         primitives, &
    2314           0 :                                         buffer1, buffer2)
    2315             : #endif
    2316             :                CASE (1)
    2317             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    2318             :                   CALL contract_sgdp(work, &
    2319             :                                      nl_a, nl_b, nl_c, nl_d, &
    2320             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    2321             :                                      primitives, &
    2322             :                                      buffer1, buffer2)
    2323             : #else
    2324             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    2325             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    2326             :                                         sphi_a, &
    2327             :                                         sphi_b, &
    2328             :                                         sphi_c, &
    2329             :                                         sphi_d, &
    2330             :                                         primitives, &
    2331           0 :                                         buffer1, buffer2)
    2332             : #endif
    2333             :                CASE (2)
    2334             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    2335             :                   CALL contract_sgdd(work, &
    2336             :                                      nl_a, nl_b, nl_c, nl_d, &
    2337             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    2338             :                                      primitives, &
    2339             :                                      buffer1, buffer2)
    2340             : #else
    2341             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    2342             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    2343             :                                         sphi_a, &
    2344             :                                         sphi_b, &
    2345             :                                         sphi_c, &
    2346             :                                         sphi_d, &
    2347             :                                         primitives, &
    2348           0 :                                         buffer1, buffer2)
    2349             : #endif
    2350             :                CASE (3)
    2351             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    2352             :                   CALL contract_sgdf(work, &
    2353             :                                      nl_a, nl_b, nl_c, nl_d, &
    2354             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    2355             :                                      primitives, &
    2356             :                                      buffer1, buffer2)
    2357             : #else
    2358             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    2359             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    2360             :                                         sphi_a, &
    2361             :                                         sphi_b, &
    2362             :                                         sphi_c, &
    2363             :                                         sphi_d, &
    2364             :                                         primitives, &
    2365           0 :                                         buffer1, buffer2)
    2366             : #endif
    2367             :                CASE (4)
    2368             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    2369             :                   CALL contract_sgdg(work, &
    2370             :                                      nl_a, nl_b, nl_c, nl_d, &
    2371             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    2372             :                                      primitives, &
    2373             :                                      buffer1, buffer2)
    2374             : #else
    2375             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    2376             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    2377             :                                         sphi_a, &
    2378             :                                         sphi_b, &
    2379             :                                         sphi_c, &
    2380             :                                         sphi_d, &
    2381             :                                         primitives, &
    2382           0 :                                         buffer1, buffer2)
    2383             : #endif
    2384             :                CASE DEFAULT
    2385             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    2386             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    2387             :                                         sphi_a, &
    2388             :                                         sphi_b, &
    2389             :                                         sphi_c, &
    2390             :                                         sphi_d, &
    2391             :                                         primitives, &
    2392           0 :                                         buffer1, buffer2)
    2393             :                END SELECT
    2394             :             CASE (3)
    2395           0 :                SELECT CASE (n_d)
    2396             :                CASE (0)
    2397             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    2398             :                   CALL contract_sgfs(work, &
    2399             :                                      nl_a, nl_b, nl_c, nl_d, &
    2400             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    2401             :                                      primitives, &
    2402             :                                      buffer1, buffer2)
    2403             : #else
    2404             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    2405             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    2406             :                                         sphi_a, &
    2407             :                                         sphi_b, &
    2408             :                                         sphi_c, &
    2409             :                                         sphi_d, &
    2410             :                                         primitives, &
    2411           0 :                                         buffer1, buffer2)
    2412             : #endif
    2413             :                CASE (1)
    2414             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    2415             :                   CALL contract_sgfp(work, &
    2416             :                                      nl_a, nl_b, nl_c, nl_d, &
    2417             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    2418             :                                      primitives, &
    2419             :                                      buffer1, buffer2)
    2420             : #else
    2421             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    2422             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    2423             :                                         sphi_a, &
    2424             :                                         sphi_b, &
    2425             :                                         sphi_c, &
    2426             :                                         sphi_d, &
    2427             :                                         primitives, &
    2428           0 :                                         buffer1, buffer2)
    2429             : #endif
    2430             :                CASE (2)
    2431             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    2432             :                   CALL contract_sgfd(work, &
    2433             :                                      nl_a, nl_b, nl_c, nl_d, &
    2434             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    2435             :                                      primitives, &
    2436             :                                      buffer1, buffer2)
    2437             : #else
    2438             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    2439             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    2440             :                                         sphi_a, &
    2441             :                                         sphi_b, &
    2442             :                                         sphi_c, &
    2443             :                                         sphi_d, &
    2444             :                                         primitives, &
    2445           0 :                                         buffer1, buffer2)
    2446             : #endif
    2447             :                CASE (3)
    2448             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    2449             :                   CALL contract_sgff(work, &
    2450             :                                      nl_a, nl_b, nl_c, nl_d, &
    2451             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    2452             :                                      primitives, &
    2453             :                                      buffer1, buffer2)
    2454             : #else
    2455             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    2456             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    2457             :                                         sphi_a, &
    2458             :                                         sphi_b, &
    2459             :                                         sphi_c, &
    2460             :                                         sphi_d, &
    2461             :                                         primitives, &
    2462           0 :                                         buffer1, buffer2)
    2463             : #endif
    2464             :                CASE (4)
    2465             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    2466             :                   CALL contract_sgfg(work, &
    2467             :                                      nl_a, nl_b, nl_c, nl_d, &
    2468             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    2469             :                                      primitives, &
    2470             :                                      buffer1, buffer2)
    2471             : #else
    2472             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    2473             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    2474             :                                         sphi_a, &
    2475             :                                         sphi_b, &
    2476             :                                         sphi_c, &
    2477             :                                         sphi_d, &
    2478             :                                         primitives, &
    2479           0 :                                         buffer1, buffer2)
    2480             : #endif
    2481             :                CASE DEFAULT
    2482             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    2483             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    2484             :                                         sphi_a, &
    2485             :                                         sphi_b, &
    2486             :                                         sphi_c, &
    2487             :                                         sphi_d, &
    2488             :                                         primitives, &
    2489           0 :                                         buffer1, buffer2)
    2490             :                END SELECT
    2491             :             CASE (4)
    2492           0 :                SELECT CASE (n_d)
    2493             :                CASE (0)
    2494             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    2495             :                   CALL contract_sggs(work, &
    2496             :                                      nl_a, nl_b, nl_c, nl_d, &
    2497             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    2498             :                                      primitives, &
    2499             :                                      buffer1, buffer2)
    2500             : #else
    2501             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    2502             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    2503             :                                         sphi_a, &
    2504             :                                         sphi_b, &
    2505             :                                         sphi_c, &
    2506             :                                         sphi_d, &
    2507             :                                         primitives, &
    2508           0 :                                         buffer1, buffer2)
    2509             : #endif
    2510             :                CASE (1)
    2511             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    2512             :                   CALL contract_sggp(work, &
    2513             :                                      nl_a, nl_b, nl_c, nl_d, &
    2514             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    2515             :                                      primitives, &
    2516             :                                      buffer1, buffer2)
    2517             : #else
    2518             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    2519             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    2520             :                                         sphi_a, &
    2521             :                                         sphi_b, &
    2522             :                                         sphi_c, &
    2523             :                                         sphi_d, &
    2524             :                                         primitives, &
    2525           0 :                                         buffer1, buffer2)
    2526             : #endif
    2527             :                CASE (2)
    2528             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    2529             :                   CALL contract_sggd(work, &
    2530             :                                      nl_a, nl_b, nl_c, nl_d, &
    2531             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    2532             :                                      primitives, &
    2533             :                                      buffer1, buffer2)
    2534             : #else
    2535             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    2536             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    2537             :                                         sphi_a, &
    2538             :                                         sphi_b, &
    2539             :                                         sphi_c, &
    2540             :                                         sphi_d, &
    2541             :                                         primitives, &
    2542           0 :                                         buffer1, buffer2)
    2543             : #endif
    2544             :                CASE (3)
    2545             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    2546             :                   CALL contract_sggf(work, &
    2547             :                                      nl_a, nl_b, nl_c, nl_d, &
    2548             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    2549             :                                      primitives, &
    2550             :                                      buffer1, buffer2)
    2551             : #else
    2552             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    2553             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    2554             :                                         sphi_a, &
    2555             :                                         sphi_b, &
    2556             :                                         sphi_c, &
    2557             :                                         sphi_d, &
    2558             :                                         primitives, &
    2559           0 :                                         buffer1, buffer2)
    2560             : #endif
    2561             :                CASE (4)
    2562             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    2563             :                   CALL contract_sggg(work, &
    2564             :                                      nl_a, nl_b, nl_c, nl_d, &
    2565             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    2566             :                                      primitives, &
    2567             :                                      buffer1, buffer2)
    2568             : #else
    2569             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    2570             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    2571             :                                         sphi_a, &
    2572             :                                         sphi_b, &
    2573             :                                         sphi_c, &
    2574             :                                         sphi_d, &
    2575             :                                         primitives, &
    2576           0 :                                         buffer1, buffer2)
    2577             : #endif
    2578             :                CASE DEFAULT
    2579             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    2580             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    2581             :                                         sphi_a, &
    2582             :                                         sphi_b, &
    2583             :                                         sphi_c, &
    2584             :                                         sphi_d, &
    2585             :                                         primitives, &
    2586           0 :                                         buffer1, buffer2)
    2587             :                END SELECT
    2588             :             CASE DEFAULT
    2589             :                CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    2590             :                                      work, nl_a, nl_b, nl_c, nl_d, &
    2591             :                                      sphi_a, &
    2592             :                                      sphi_b, &
    2593             :                                      sphi_c, &
    2594             :                                      sphi_d, &
    2595             :                                      primitives, &
    2596           0 :                                      buffer1, buffer2)
    2597             :             END SELECT
    2598             :          CASE DEFAULT
    2599             :             CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    2600             :                                   work, nl_a, nl_b, nl_c, nl_d, &
    2601             :                                   sphi_a, &
    2602             :                                   sphi_b, &
    2603             :                                   sphi_c, &
    2604             :                                   sphi_d, &
    2605             :                                   primitives, &
    2606   269786270 :                                   buffer1, buffer2)
    2607             :          END SELECT
    2608             :       CASE (1)
    2609   192992538 :          SELECT CASE (n_b)
    2610             :          CASE (0)
    2611   140021163 :             SELECT CASE (n_c)
    2612             :             CASE (0)
    2613   108981987 :                SELECT CASE (n_d)
    2614             :                CASE (0)
    2615             : #if __MAX_CONTR > 1 || __MAX_CONTR == 1
    2616             :                   CALL contract_psss(work, &
    2617             :                                      nl_a, nl_b, nl_c, nl_d, &
    2618             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    2619             :                                      primitives, &
    2620    33164615 :                                      buffer1, buffer2)
    2621             : #else
    2622             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    2623             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    2624             :                                         sphi_a, &
    2625             :                                         sphi_b, &
    2626             :                                         sphi_c, &
    2627             :                                         sphi_d, &
    2628             :                                         primitives, &
    2629             :                                         buffer1, buffer2)
    2630             : #endif
    2631             :                CASE (1)
    2632             : #if __MAX_CONTR > 1 || __MAX_CONTR == 1
    2633             :                   CALL contract_pssp(work, &
    2634             :                                      nl_a, nl_b, nl_c, nl_d, &
    2635             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    2636             :                                      primitives, &
    2637     9863180 :                                      buffer1, buffer2)
    2638             : #else
    2639             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    2640             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    2641             :                                         sphi_a, &
    2642             :                                         sphi_b, &
    2643             :                                         sphi_c, &
    2644             :                                         sphi_d, &
    2645             :                                         primitives, &
    2646             :                                         buffer1, buffer2)
    2647             : #endif
    2648             :                CASE (2)
    2649             : #if __MAX_CONTR > 2 || __MAX_CONTR == 2
    2650             :                   CALL contract_pssd(work, &
    2651             :                                      nl_a, nl_b, nl_c, nl_d, &
    2652             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    2653             :                                      primitives, &
    2654     1385469 :                                      buffer1, buffer2)
    2655             : #else
    2656             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    2657             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    2658             :                                         sphi_a, &
    2659             :                                         sphi_b, &
    2660             :                                         sphi_c, &
    2661             :                                         sphi_d, &
    2662             :                                         primitives, &
    2663             :                                         buffer1, buffer2)
    2664             : #endif
    2665             :                CASE (3)
    2666             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    2667             :                   CALL contract_pssf(work, &
    2668             :                                      nl_a, nl_b, nl_c, nl_d, &
    2669             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    2670             :                                      primitives, &
    2671             :                                      buffer1, buffer2)
    2672             : #else
    2673             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    2674             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    2675             :                                         sphi_a, &
    2676             :                                         sphi_b, &
    2677             :                                         sphi_c, &
    2678             :                                         sphi_d, &
    2679             :                                         primitives, &
    2680       13955 :                                         buffer1, buffer2)
    2681             : #endif
    2682             :                CASE (4)
    2683             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    2684             :                   CALL contract_pssg(work, &
    2685             :                                      nl_a, nl_b, nl_c, nl_d, &
    2686             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    2687             :                                      primitives, &
    2688             :                                      buffer1, buffer2)
    2689             : #else
    2690             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    2691             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    2692             :                                         sphi_a, &
    2693             :                                         sphi_b, &
    2694             :                                         sphi_c, &
    2695             :                                         sphi_d, &
    2696             :                                         primitives, &
    2697           0 :                                         buffer1, buffer2)
    2698             : #endif
    2699             :                CASE DEFAULT
    2700             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    2701             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    2702             :                                         sphi_a, &
    2703             :                                         sphi_b, &
    2704             :                                         sphi_c, &
    2705             :                                         sphi_d, &
    2706             :                                         primitives, &
    2707    44427219 :                                         buffer1, buffer2)
    2708             :                END SELECT
    2709             :             CASE (1)
    2710    55367410 :                SELECT CASE (n_d)
    2711             :                CASE (0)
    2712             : #if __MAX_CONTR > 1 || __MAX_CONTR == 1
    2713             :                   CALL contract_psps(work, &
    2714             :                                      nl_a, nl_b, nl_c, nl_d, &
    2715             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    2716             :                                      primitives, &
    2717    20637825 :                                      buffer1, buffer2)
    2718             : #else
    2719             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    2720             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    2721             :                                         sphi_a, &
    2722             :                                         sphi_b, &
    2723             :                                         sphi_c, &
    2724             :                                         sphi_d, &
    2725             :                                         primitives, &
    2726             :                                         buffer1, buffer2)
    2727             : #endif
    2728             :                CASE (1)
    2729             : #if __MAX_CONTR > 1 || __MAX_CONTR == 1
    2730             :                   CALL contract_pspp(work, &
    2731             :                                      nl_a, nl_b, nl_c, nl_d, &
    2732             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    2733             :                                      primitives, &
    2734     9791127 :                                      buffer1, buffer2)
    2735             : #else
    2736             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    2737             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    2738             :                                         sphi_a, &
    2739             :                                         sphi_b, &
    2740             :                                         sphi_c, &
    2741             :                                         sphi_d, &
    2742             :                                         primitives, &
    2743             :                                         buffer1, buffer2)
    2744             : #endif
    2745             :                CASE (2)
    2746             : #if __MAX_CONTR > 2 || __MAX_CONTR == 2
    2747             :                   CALL contract_pspd(work, &
    2748             :                                      nl_a, nl_b, nl_c, nl_d, &
    2749             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    2750             :                                      primitives, &
    2751      954858 :                                      buffer1, buffer2)
    2752             : #else
    2753             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    2754             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    2755             :                                         sphi_a, &
    2756             :                                         sphi_b, &
    2757             :                                         sphi_c, &
    2758             :                                         sphi_d, &
    2759             :                                         primitives, &
    2760             :                                         buffer1, buffer2)
    2761             : #endif
    2762             :                CASE (3)
    2763             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    2764             :                   CALL contract_pspf(work, &
    2765             :                                      nl_a, nl_b, nl_c, nl_d, &
    2766             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    2767             :                                      primitives, &
    2768             :                                      buffer1, buffer2)
    2769             : #else
    2770             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    2771             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    2772             :                                         sphi_a, &
    2773             :                                         sphi_b, &
    2774             :                                         sphi_c, &
    2775             :                                         sphi_d, &
    2776             :                                         primitives, &
    2777        6343 :                                         buffer1, buffer2)
    2778             : #endif
    2779             :                CASE (4)
    2780             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    2781             :                   CALL contract_pspg(work, &
    2782             :                                      nl_a, nl_b, nl_c, nl_d, &
    2783             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    2784             :                                      primitives, &
    2785             :                                      buffer1, buffer2)
    2786             : #else
    2787             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    2788             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    2789             :                                         sphi_a, &
    2790             :                                         sphi_b, &
    2791             :                                         sphi_c, &
    2792             :                                         sphi_d, &
    2793             :                                         primitives, &
    2794           0 :                                         buffer1, buffer2)
    2795             : #endif
    2796             :                CASE DEFAULT
    2797             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    2798             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    2799             :                                         sphi_a, &
    2800             :                                         sphi_b, &
    2801             :                                         sphi_c, &
    2802             :                                         sphi_d, &
    2803             :                                         primitives, &
    2804    31390153 :                                         buffer1, buffer2)
    2805             :                END SELECT
    2806             :             CASE (2)
    2807     5391461 :                SELECT CASE (n_d)
    2808             :                CASE (0)
    2809             : #if __MAX_CONTR > 2 || __MAX_CONTR == 2
    2810             :                   CALL contract_psds(work, &
    2811             :                                      nl_a, nl_b, nl_c, nl_d, &
    2812             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    2813             :                                      primitives, &
    2814     2009045 :                                      buffer1, buffer2)
    2815             : #else
    2816             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    2817             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    2818             :                                         sphi_a, &
    2819             :                                         sphi_b, &
    2820             :                                         sphi_c, &
    2821             :                                         sphi_d, &
    2822             :                                         primitives, &
    2823             :                                         buffer1, buffer2)
    2824             : #endif
    2825             :                CASE (1)
    2826             : #if __MAX_CONTR > 2 || __MAX_CONTR == 2
    2827             :                   CALL contract_psdp(work, &
    2828             :                                      nl_a, nl_b, nl_c, nl_d, &
    2829             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    2830             :                                      primitives, &
    2831      961267 :                                      buffer1, buffer2)
    2832             : #else
    2833             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    2834             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    2835             :                                         sphi_a, &
    2836             :                                         sphi_b, &
    2837             :                                         sphi_c, &
    2838             :                                         sphi_d, &
    2839             :                                         primitives, &
    2840             :                                         buffer1, buffer2)
    2841             : #endif
    2842             :                CASE (2)
    2843             : #if __MAX_CONTR > 2 || __MAX_CONTR == 2
    2844             :                   CALL contract_psdd(work, &
    2845             :                                      nl_a, nl_b, nl_c, nl_d, &
    2846             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    2847             :                                      primitives, &
    2848      364213 :                                      buffer1, buffer2)
    2849             : #else
    2850             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    2851             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    2852             :                                         sphi_a, &
    2853             :                                         sphi_b, &
    2854             :                                         sphi_c, &
    2855             :                                         sphi_d, &
    2856             :                                         primitives, &
    2857             :                                         buffer1, buffer2)
    2858             : #endif
    2859             :                CASE (3)
    2860             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    2861             :                   CALL contract_psdf(work, &
    2862             :                                      nl_a, nl_b, nl_c, nl_d, &
    2863             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    2864             :                                      primitives, &
    2865             :                                      buffer1, buffer2)
    2866             : #else
    2867             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    2868             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    2869             :                                         sphi_a, &
    2870             :                                         sphi_b, &
    2871             :                                         sphi_c, &
    2872             :                                         sphi_d, &
    2873             :                                         primitives, &
    2874        4907 :                                         buffer1, buffer2)
    2875             : #endif
    2876             :                CASE (4)
    2877             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    2878             :                   CALL contract_psdg(work, &
    2879             :                                      nl_a, nl_b, nl_c, nl_d, &
    2880             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    2881             :                                      primitives, &
    2882             :                                      buffer1, buffer2)
    2883             : #else
    2884             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    2885             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    2886             :                                         sphi_a, &
    2887             :                                         sphi_b, &
    2888             :                                         sphi_c, &
    2889             :                                         sphi_d, &
    2890             :                                         primitives, &
    2891           0 :                                         buffer1, buffer2)
    2892             : #endif
    2893             :                CASE DEFAULT
    2894             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    2895             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    2896             :                                         sphi_a, &
    2897             :                                         sphi_b, &
    2898             :                                         sphi_c, &
    2899             :                                         sphi_d, &
    2900             :                                         primitives, &
    2901     3339432 :                                         buffer1, buffer2)
    2902             :                END SELECT
    2903             :             CASE (3)
    2904       73971 :                SELECT CASE (n_d)
    2905             :                CASE (0)
    2906             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    2907             :                   CALL contract_psfs(work, &
    2908             :                                      nl_a, nl_b, nl_c, nl_d, &
    2909             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    2910             :                                      primitives, &
    2911             :                                      buffer1, buffer2)
    2912             : #else
    2913             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    2914             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    2915             :                                         sphi_a, &
    2916             :                                         sphi_b, &
    2917             :                                         sphi_c, &
    2918             :                                         sphi_d, &
    2919             :                                         primitives, &
    2920       30987 :                                         buffer1, buffer2)
    2921             : #endif
    2922             :                CASE (1)
    2923             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    2924             :                   CALL contract_psfp(work, &
    2925             :                                      nl_a, nl_b, nl_c, nl_d, &
    2926             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    2927             :                                      primitives, &
    2928             :                                      buffer1, buffer2)
    2929             : #else
    2930             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    2931             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    2932             :                                         sphi_a, &
    2933             :                                         sphi_b, &
    2934             :                                         sphi_c, &
    2935             :                                         sphi_d, &
    2936             :                                         primitives, &
    2937        6526 :                                         buffer1, buffer2)
    2938             : #endif
    2939             :                CASE (2)
    2940             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    2941             :                   CALL contract_psfd(work, &
    2942             :                                      nl_a, nl_b, nl_c, nl_d, &
    2943             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    2944             :                                      primitives, &
    2945             :                                      buffer1, buffer2)
    2946             : #else
    2947             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    2948             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    2949             :                                         sphi_a, &
    2950             :                                         sphi_b, &
    2951             :                                         sphi_c, &
    2952             :                                         sphi_d, &
    2953             :                                         primitives, &
    2954        4107 :                                         buffer1, buffer2)
    2955             : #endif
    2956             :                CASE (3)
    2957             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    2958             :                   CALL contract_psff(work, &
    2959             :                                      nl_a, nl_b, nl_c, nl_d, &
    2960             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    2961             :                                      primitives, &
    2962             :                                      buffer1, buffer2)
    2963             : #else
    2964             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    2965             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    2966             :                                         sphi_a, &
    2967             :                                         sphi_b, &
    2968             :                                         sphi_c, &
    2969             :                                         sphi_d, &
    2970             :                                         primitives, &
    2971        1364 :                                         buffer1, buffer2)
    2972             : #endif
    2973             :                CASE (4)
    2974             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    2975             :                   CALL contract_psfg(work, &
    2976             :                                      nl_a, nl_b, nl_c, nl_d, &
    2977             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    2978             :                                      primitives, &
    2979             :                                      buffer1, buffer2)
    2980             : #else
    2981             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    2982             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    2983             :                                         sphi_a, &
    2984             :                                         sphi_b, &
    2985             :                                         sphi_c, &
    2986             :                                         sphi_d, &
    2987             :                                         primitives, &
    2988           0 :                                         buffer1, buffer2)
    2989             : #endif
    2990             :                CASE DEFAULT
    2991             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    2992             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    2993             :                                         sphi_a, &
    2994             :                                         sphi_b, &
    2995             :                                         sphi_c, &
    2996             :                                         sphi_d, &
    2997             :                                         primitives, &
    2998       42984 :                                         buffer1, buffer2)
    2999             :                END SELECT
    3000             :             CASE (4)
    3001           0 :                SELECT CASE (n_d)
    3002             :                CASE (0)
    3003             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    3004             :                   CALL contract_psgs(work, &
    3005             :                                      nl_a, nl_b, nl_c, nl_d, &
    3006             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    3007             :                                      primitives, &
    3008             :                                      buffer1, buffer2)
    3009             : #else
    3010             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    3011             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    3012             :                                         sphi_a, &
    3013             :                                         sphi_b, &
    3014             :                                         sphi_c, &
    3015             :                                         sphi_d, &
    3016             :                                         primitives, &
    3017           0 :                                         buffer1, buffer2)
    3018             : #endif
    3019             :                CASE (1)
    3020             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    3021             :                   CALL contract_psgp(work, &
    3022             :                                      nl_a, nl_b, nl_c, nl_d, &
    3023             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    3024             :                                      primitives, &
    3025             :                                      buffer1, buffer2)
    3026             : #else
    3027             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    3028             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    3029             :                                         sphi_a, &
    3030             :                                         sphi_b, &
    3031             :                                         sphi_c, &
    3032             :                                         sphi_d, &
    3033             :                                         primitives, &
    3034           0 :                                         buffer1, buffer2)
    3035             : #endif
    3036             :                CASE (2)
    3037             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    3038             :                   CALL contract_psgd(work, &
    3039             :                                      nl_a, nl_b, nl_c, nl_d, &
    3040             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    3041             :                                      primitives, &
    3042             :                                      buffer1, buffer2)
    3043             : #else
    3044             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    3045             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    3046             :                                         sphi_a, &
    3047             :                                         sphi_b, &
    3048             :                                         sphi_c, &
    3049             :                                         sphi_d, &
    3050             :                                         primitives, &
    3051           0 :                                         buffer1, buffer2)
    3052             : #endif
    3053             :                CASE (3)
    3054             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    3055             :                   CALL contract_psgf(work, &
    3056             :                                      nl_a, nl_b, nl_c, nl_d, &
    3057             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    3058             :                                      primitives, &
    3059             :                                      buffer1, buffer2)
    3060             : #else
    3061             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    3062             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    3063             :                                         sphi_a, &
    3064             :                                         sphi_b, &
    3065             :                                         sphi_c, &
    3066             :                                         sphi_d, &
    3067             :                                         primitives, &
    3068           0 :                                         buffer1, buffer2)
    3069             : #endif
    3070             :                CASE (4)
    3071             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    3072             :                   CALL contract_psgg(work, &
    3073             :                                      nl_a, nl_b, nl_c, nl_d, &
    3074             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    3075             :                                      primitives, &
    3076             :                                      buffer1, buffer2)
    3077             : #else
    3078             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    3079             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    3080             :                                         sphi_a, &
    3081             :                                         sphi_b, &
    3082             :                                         sphi_c, &
    3083             :                                         sphi_d, &
    3084             :                                         primitives, &
    3085           0 :                                         buffer1, buffer2)
    3086             : #endif
    3087             :                CASE DEFAULT
    3088             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    3089             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    3090             :                                         sphi_a, &
    3091             :                                         sphi_b, &
    3092             :                                         sphi_c, &
    3093             :                                         sphi_d, &
    3094             :                                         primitives, &
    3095           0 :                                         buffer1, buffer2)
    3096             :                END SELECT
    3097             :             CASE DEFAULT
    3098             :                CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    3099             :                                      work, nl_a, nl_b, nl_c, nl_d, &
    3100             :                                      sphi_a, &
    3101             :                                      sphi_b, &
    3102             :                                      sphi_c, &
    3103             :                                      sphi_d, &
    3104             :                                      primitives, &
    3105    79199788 :                                      buffer1, buffer2)
    3106             :             END SELECT
    3107             :          CASE (1)
    3108    28745528 :             SELECT CASE (n_c)
    3109             :             CASE (0)
    3110    19537349 :                SELECT CASE (n_d)
    3111             :                CASE (0)
    3112             : #if __MAX_CONTR > 1 || __MAX_CONTR == 1
    3113             :                   CALL contract_ppss(work, &
    3114             :                                      nl_a, nl_b, nl_c, nl_d, &
    3115             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    3116             :                                      primitives, &
    3117     4342212 :                                      buffer1, buffer2)
    3118             : #else
    3119             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    3120             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    3121             :                                         sphi_a, &
    3122             :                                         sphi_b, &
    3123             :                                         sphi_c, &
    3124             :                                         sphi_d, &
    3125             :                                         primitives, &
    3126             :                                         buffer1, buffer2)
    3127             : #endif
    3128             :                CASE (1)
    3129             : #if __MAX_CONTR > 1 || __MAX_CONTR == 1
    3130             :                   CALL contract_ppsp(work, &
    3131             :                                      nl_a, nl_b, nl_c, nl_d, &
    3132             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    3133             :                                      primitives, &
    3134     4010351 :                                      buffer1, buffer2)
    3135             : #else
    3136             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    3137             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    3138             :                                         sphi_a, &
    3139             :                                         sphi_b, &
    3140             :                                         sphi_c, &
    3141             :                                         sphi_d, &
    3142             :                                         primitives, &
    3143             :                                         buffer1, buffer2)
    3144             : #endif
    3145             :                CASE (2)
    3146             : #if __MAX_CONTR > 2 || __MAX_CONTR == 2
    3147             :                   CALL contract_ppsd(work, &
    3148             :                                      nl_a, nl_b, nl_c, nl_d, &
    3149             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    3150             :                                      primitives, &
    3151      542259 :                                      buffer1, buffer2)
    3152             : #else
    3153             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    3154             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    3155             :                                         sphi_a, &
    3156             :                                         sphi_b, &
    3157             :                                         sphi_c, &
    3158             :                                         sphi_d, &
    3159             :                                         primitives, &
    3160             :                                         buffer1, buffer2)
    3161             : #endif
    3162             :                CASE (3)
    3163             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    3164             :                   CALL contract_ppsf(work, &
    3165             :                                      nl_a, nl_b, nl_c, nl_d, &
    3166             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    3167             :                                      primitives, &
    3168             :                                      buffer1, buffer2)
    3169             : #else
    3170             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    3171             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    3172             :                                         sphi_a, &
    3173             :                                         sphi_b, &
    3174             :                                         sphi_c, &
    3175             :                                         sphi_d, &
    3176             :                                         primitives, &
    3177        4876 :                                         buffer1, buffer2)
    3178             : #endif
    3179             :                CASE (4)
    3180             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    3181             :                   CALL contract_ppsg(work, &
    3182             :                                      nl_a, nl_b, nl_c, nl_d, &
    3183             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    3184             :                                      primitives, &
    3185             :                                      buffer1, buffer2)
    3186             : #else
    3187             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    3188             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    3189             :                                         sphi_a, &
    3190             :                                         sphi_b, &
    3191             :                                         sphi_c, &
    3192             :                                         sphi_d, &
    3193             :                                         primitives, &
    3194           0 :                                         buffer1, buffer2)
    3195             : #endif
    3196             :                CASE DEFAULT
    3197             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    3198             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    3199             :                                         sphi_a, &
    3200             :                                         sphi_b, &
    3201             :                                         sphi_c, &
    3202             :                                         sphi_d, &
    3203             :                                         primitives, &
    3204     8899698 :                                         buffer1, buffer2)
    3205             :                END SELECT
    3206             :             CASE (1)
    3207    11563318 :                SELECT CASE (n_d)
    3208             :                CASE (0)
    3209             : #if __MAX_CONTR > 1 || __MAX_CONTR == 1
    3210             :                   CALL contract_ppps(work, &
    3211             :                                      nl_a, nl_b, nl_c, nl_d, &
    3212             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    3213             :                                      primitives, &
    3214     4082685 :                                      buffer1, buffer2)
    3215             : #else
    3216             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    3217             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    3218             :                                         sphi_a, &
    3219             :                                         sphi_b, &
    3220             :                                         sphi_c, &
    3221             :                                         sphi_d, &
    3222             :                                         primitives, &
    3223             :                                         buffer1, buffer2)
    3224             : #endif
    3225             :                CASE (1)
    3226             : #if __MAX_CONTR > 1 || __MAX_CONTR == 1
    3227             :                   CALL contract_pppp(work, &
    3228             :                                      nl_a, nl_b, nl_c, nl_d, &
    3229             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    3230             :                                      primitives, &
    3231     1695357 :                                      buffer1, buffer2)
    3232             : #else
    3233             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    3234             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    3235             :                                         sphi_a, &
    3236             :                                         sphi_b, &
    3237             :                                         sphi_c, &
    3238             :                                         sphi_d, &
    3239             :                                         primitives, &
    3240             :                                         buffer1, buffer2)
    3241             : #endif
    3242             :                CASE (2)
    3243             : #if __MAX_CONTR > 2 || __MAX_CONTR == 2
    3244             :                   CALL contract_pppd(work, &
    3245             :                                      nl_a, nl_b, nl_c, nl_d, &
    3246             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    3247             :                                      primitives, &
    3248      508872 :                                      buffer1, buffer2)
    3249             : #else
    3250             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    3251             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    3252             :                                         sphi_a, &
    3253             :                                         sphi_b, &
    3254             :                                         sphi_c, &
    3255             :                                         sphi_d, &
    3256             :                                         primitives, &
    3257             :                                         buffer1, buffer2)
    3258             : #endif
    3259             :                CASE (3)
    3260             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    3261             :                   CALL contract_pppf(work, &
    3262             :                                      nl_a, nl_b, nl_c, nl_d, &
    3263             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    3264             :                                      primitives, &
    3265             :                                      buffer1, buffer2)
    3266             : #else
    3267             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    3268             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    3269             :                                         sphi_a, &
    3270             :                                         sphi_b, &
    3271             :                                         sphi_c, &
    3272             :                                         sphi_d, &
    3273             :                                         primitives, &
    3274        8525 :                                         buffer1, buffer2)
    3275             : #endif
    3276             :                CASE (4)
    3277             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    3278             :                   CALL contract_pppg(work, &
    3279             :                                      nl_a, nl_b, nl_c, nl_d, &
    3280             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    3281             :                                      primitives, &
    3282             :                                      buffer1, buffer2)
    3283             : #else
    3284             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    3285             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    3286             :                                         sphi_a, &
    3287             :                                         sphi_b, &
    3288             :                                         sphi_c, &
    3289             :                                         sphi_d, &
    3290             :                                         primitives, &
    3291           0 :                                         buffer1, buffer2)
    3292             : #endif
    3293             :                CASE DEFAULT
    3294             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    3295             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    3296             :                                         sphi_a, &
    3297             :                                         sphi_b, &
    3298             :                                         sphi_c, &
    3299             :                                         sphi_d, &
    3300             :                                         primitives, &
    3301     6295439 :                                         buffer1, buffer2)
    3302             :                END SELECT
    3303             :             CASE (2)
    3304     1736423 :                SELECT CASE (n_d)
    3305             :                CASE (0)
    3306             : #if __MAX_CONTR > 2 || __MAX_CONTR == 2
    3307             :                   CALL contract_ppds(work, &
    3308             :                                      nl_a, nl_b, nl_c, nl_d, &
    3309             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    3310             :                                      primitives, &
    3311      537404 :                                      buffer1, buffer2)
    3312             : #else
    3313             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    3314             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    3315             :                                         sphi_a, &
    3316             :                                         sphi_b, &
    3317             :                                         sphi_c, &
    3318             :                                         sphi_d, &
    3319             :                                         primitives, &
    3320             :                                         buffer1, buffer2)
    3321             : #endif
    3322             :                CASE (1)
    3323             : #if __MAX_CONTR > 2 || __MAX_CONTR == 2
    3324             :                   CALL contract_ppdp(work, &
    3325             :                                      nl_a, nl_b, nl_c, nl_d, &
    3326             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    3327             :                                      primitives, &
    3328      481325 :                                      buffer1, buffer2)
    3329             : #else
    3330             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    3331             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    3332             :                                         sphi_a, &
    3333             :                                         sphi_b, &
    3334             :                                         sphi_c, &
    3335             :                                         sphi_d, &
    3336             :                                         primitives, &
    3337             :                                         buffer1, buffer2)
    3338             : #endif
    3339             :                CASE (2)
    3340             : #if __MAX_CONTR > 2 || __MAX_CONTR == 2
    3341             :                   CALL contract_ppdd(work, &
    3342             :                                      nl_a, nl_b, nl_c, nl_d, &
    3343             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    3344             :                                      primitives, &
    3345      164369 :                                      buffer1, buffer2)
    3346             : #else
    3347             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    3348             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    3349             :                                         sphi_a, &
    3350             :                                         sphi_b, &
    3351             :                                         sphi_c, &
    3352             :                                         sphi_d, &
    3353             :                                         primitives, &
    3354             :                                         buffer1, buffer2)
    3355             : #endif
    3356             :                CASE (3)
    3357             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    3358             :                   CALL contract_ppdf(work, &
    3359             :                                      nl_a, nl_b, nl_c, nl_d, &
    3360             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    3361             :                                      primitives, &
    3362             :                                      buffer1, buffer2)
    3363             : #else
    3364             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    3365             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    3366             :                                         sphi_a, &
    3367             :                                         sphi_b, &
    3368             :                                         sphi_c, &
    3369             :                                         sphi_d, &
    3370             :                                         primitives, &
    3371        2096 :                                         buffer1, buffer2)
    3372             : #endif
    3373             :                CASE (4)
    3374             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    3375             :                   CALL contract_ppdg(work, &
    3376             :                                      nl_a, nl_b, nl_c, nl_d, &
    3377             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    3378             :                                      primitives, &
    3379             :                                      buffer1, buffer2)
    3380             : #else
    3381             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    3382             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    3383             :                                         sphi_a, &
    3384             :                                         sphi_b, &
    3385             :                                         sphi_c, &
    3386             :                                         sphi_d, &
    3387             :                                         primitives, &
    3388           0 :                                         buffer1, buffer2)
    3389             : #endif
    3390             :                CASE DEFAULT
    3391             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    3392             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    3393             :                                         sphi_a, &
    3394             :                                         sphi_b, &
    3395             :                                         sphi_c, &
    3396             :                                         sphi_d, &
    3397             :                                         primitives, &
    3398     1185194 :                                         buffer1, buffer2)
    3399             :                END SELECT
    3400             :             CASE (3)
    3401       18235 :                SELECT CASE (n_d)
    3402             :                CASE (0)
    3403             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    3404             :                   CALL contract_ppfs(work, &
    3405             :                                      nl_a, nl_b, nl_c, nl_d, &
    3406             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    3407             :                                      primitives, &
    3408             :                                      buffer1, buffer2)
    3409             : #else
    3410             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    3411             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    3412             :                                         sphi_a, &
    3413             :                                         sphi_b, &
    3414             :                                         sphi_c, &
    3415             :                                         sphi_d, &
    3416             :                                         primitives, &
    3417        4410 :                                         buffer1, buffer2)
    3418             : #endif
    3419             :                CASE (1)
    3420             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    3421             :                   CALL contract_ppfp(work, &
    3422             :                                      nl_a, nl_b, nl_c, nl_d, &
    3423             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    3424             :                                      primitives, &
    3425             :                                      buffer1, buffer2)
    3426             : #else
    3427             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    3428             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    3429             :                                         sphi_a, &
    3430             :                                         sphi_b, &
    3431             :                                         sphi_c, &
    3432             :                                         sphi_d, &
    3433             :                                         primitives, &
    3434        5857 :                                         buffer1, buffer2)
    3435             : #endif
    3436             :                CASE (2)
    3437             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    3438             :                   CALL contract_ppfd(work, &
    3439             :                                      nl_a, nl_b, nl_c, nl_d, &
    3440             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    3441             :                                      primitives, &
    3442             :                                      buffer1, buffer2)
    3443             : #else
    3444             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    3445             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    3446             :                                         sphi_a, &
    3447             :                                         sphi_b, &
    3448             :                                         sphi_c, &
    3449             :                                         sphi_d, &
    3450             :                                         primitives, &
    3451        1441 :                                         buffer1, buffer2)
    3452             : #endif
    3453             :                CASE (3)
    3454             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    3455             :                   CALL contract_ppff(work, &
    3456             :                                      nl_a, nl_b, nl_c, nl_d, &
    3457             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    3458             :                                      primitives, &
    3459             :                                      buffer1, buffer2)
    3460             : #else
    3461             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    3462             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    3463             :                                         sphi_a, &
    3464             :                                         sphi_b, &
    3465             :                                         sphi_c, &
    3466             :                                         sphi_d, &
    3467             :                                         primitives, &
    3468        2117 :                                         buffer1, buffer2)
    3469             : #endif
    3470             :                CASE (4)
    3471             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    3472             :                   CALL contract_ppfg(work, &
    3473             :                                      nl_a, nl_b, nl_c, nl_d, &
    3474             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    3475             :                                      primitives, &
    3476             :                                      buffer1, buffer2)
    3477             : #else
    3478             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    3479             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    3480             :                                         sphi_a, &
    3481             :                                         sphi_b, &
    3482             :                                         sphi_c, &
    3483             :                                         sphi_d, &
    3484             :                                         primitives, &
    3485           0 :                                         buffer1, buffer2)
    3486             : #endif
    3487             :                CASE DEFAULT
    3488             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    3489             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    3490             :                                         sphi_a, &
    3491             :                                         sphi_b, &
    3492             :                                         sphi_c, &
    3493             :                                         sphi_d, &
    3494             :                                         primitives, &
    3495       13825 :                                         buffer1, buffer2)
    3496             :                END SELECT
    3497             :             CASE (4)
    3498           0 :                SELECT CASE (n_d)
    3499             :                CASE (0)
    3500             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    3501             :                   CALL contract_ppgs(work, &
    3502             :                                      nl_a, nl_b, nl_c, nl_d, &
    3503             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    3504             :                                      primitives, &
    3505             :                                      buffer1, buffer2)
    3506             : #else
    3507             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    3508             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    3509             :                                         sphi_a, &
    3510             :                                         sphi_b, &
    3511             :                                         sphi_c, &
    3512             :                                         sphi_d, &
    3513             :                                         primitives, &
    3514           0 :                                         buffer1, buffer2)
    3515             : #endif
    3516             :                CASE (1)
    3517             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    3518             :                   CALL contract_ppgp(work, &
    3519             :                                      nl_a, nl_b, nl_c, nl_d, &
    3520             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    3521             :                                      primitives, &
    3522             :                                      buffer1, buffer2)
    3523             : #else
    3524             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    3525             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    3526             :                                         sphi_a, &
    3527             :                                         sphi_b, &
    3528             :                                         sphi_c, &
    3529             :                                         sphi_d, &
    3530             :                                         primitives, &
    3531           0 :                                         buffer1, buffer2)
    3532             : #endif
    3533             :                CASE (2)
    3534             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    3535             :                   CALL contract_ppgd(work, &
    3536             :                                      nl_a, nl_b, nl_c, nl_d, &
    3537             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    3538             :                                      primitives, &
    3539             :                                      buffer1, buffer2)
    3540             : #else
    3541             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    3542             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    3543             :                                         sphi_a, &
    3544             :                                         sphi_b, &
    3545             :                                         sphi_c, &
    3546             :                                         sphi_d, &
    3547             :                                         primitives, &
    3548           0 :                                         buffer1, buffer2)
    3549             : #endif
    3550             :                CASE (3)
    3551             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    3552             :                   CALL contract_ppgf(work, &
    3553             :                                      nl_a, nl_b, nl_c, nl_d, &
    3554             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    3555             :                                      primitives, &
    3556             :                                      buffer1, buffer2)
    3557             : #else
    3558             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    3559             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    3560             :                                         sphi_a, &
    3561             :                                         sphi_b, &
    3562             :                                         sphi_c, &
    3563             :                                         sphi_d, &
    3564             :                                         primitives, &
    3565           0 :                                         buffer1, buffer2)
    3566             : #endif
    3567             :                CASE (4)
    3568             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    3569             :                   CALL contract_ppgg(work, &
    3570             :                                      nl_a, nl_b, nl_c, nl_d, &
    3571             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    3572             :                                      primitives, &
    3573             :                                      buffer1, buffer2)
    3574             : #else
    3575             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    3576             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    3577             :                                         sphi_a, &
    3578             :                                         sphi_b, &
    3579             :                                         sphi_c, &
    3580             :                                         sphi_d, &
    3581             :                                         primitives, &
    3582           0 :                                         buffer1, buffer2)
    3583             : #endif
    3584             :                CASE DEFAULT
    3585             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    3586             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    3587             :                                         sphi_a, &
    3588             :                                         sphi_b, &
    3589             :                                         sphi_c, &
    3590             :                                         sphi_d, &
    3591             :                                         primitives, &
    3592           0 :                                         buffer1, buffer2)
    3593             :                END SELECT
    3594             :             CASE DEFAULT
    3595             :                CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    3596             :                                      work, nl_a, nl_b, nl_c, nl_d, &
    3597             :                                      sphi_a, &
    3598             :                                      sphi_b, &
    3599             :                                      sphi_c, &
    3600             :                                      sphi_d, &
    3601             :                                      primitives, &
    3602    16394156 :                                      buffer1, buffer2)
    3603             :             END SELECT
    3604             :          CASE (2)
    3605     5390837 :             SELECT CASE (n_c)
    3606             :             CASE (0)
    3607     4007865 :                SELECT CASE (n_d)
    3608             :                CASE (0)
    3609             : #if __MAX_CONTR > 2 || __MAX_CONTR == 2
    3610             :                   CALL contract_pdss(work, &
    3611             :                                      nl_a, nl_b, nl_c, nl_d, &
    3612             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    3613             :                                      primitives, &
    3614      989729 :                                      buffer1, buffer2)
    3615             : #else
    3616             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    3617             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    3618             :                                         sphi_a, &
    3619             :                                         sphi_b, &
    3620             :                                         sphi_c, &
    3621             :                                         sphi_d, &
    3622             :                                         primitives, &
    3623             :                                         buffer1, buffer2)
    3624             : #endif
    3625             :                CASE (1)
    3626             : #if __MAX_CONTR > 2 || __MAX_CONTR == 2
    3627             :                   CALL contract_pdsp(work, &
    3628             :                                      nl_a, nl_b, nl_c, nl_d, &
    3629             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    3630             :                                      primitives, &
    3631      561322 :                                      buffer1, buffer2)
    3632             : #else
    3633             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    3634             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    3635             :                                         sphi_a, &
    3636             :                                         sphi_b, &
    3637             :                                         sphi_c, &
    3638             :                                         sphi_d, &
    3639             :                                         primitives, &
    3640             :                                         buffer1, buffer2)
    3641             : #endif
    3642             :                CASE (2)
    3643             : #if __MAX_CONTR > 2 || __MAX_CONTR == 2
    3644             :                   CALL contract_pdsd(work, &
    3645             :                                      nl_a, nl_b, nl_c, nl_d, &
    3646             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    3647             :                                      primitives, &
    3648      323262 :                                      buffer1, buffer2)
    3649             : #else
    3650             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    3651             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    3652             :                                         sphi_a, &
    3653             :                                         sphi_b, &
    3654             :                                         sphi_c, &
    3655             :                                         sphi_d, &
    3656             :                                         primitives, &
    3657             :                                         buffer1, buffer2)
    3658             : #endif
    3659             :                CASE (3)
    3660             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    3661             :                   CALL contract_pdsf(work, &
    3662             :                                      nl_a, nl_b, nl_c, nl_d, &
    3663             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    3664             :                                      primitives, &
    3665             :                                      buffer1, buffer2)
    3666             : #else
    3667             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    3668             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    3669             :                                         sphi_a, &
    3670             :                                         sphi_b, &
    3671             :                                         sphi_c, &
    3672             :                                         sphi_d, &
    3673             :                                         primitives, &
    3674        5385 :                                         buffer1, buffer2)
    3675             : #endif
    3676             :                CASE (4)
    3677             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    3678             :                   CALL contract_pdsg(work, &
    3679             :                                      nl_a, nl_b, nl_c, nl_d, &
    3680             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    3681             :                                      primitives, &
    3682             :                                      buffer1, buffer2)
    3683             : #else
    3684             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    3685             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    3686             :                                         sphi_a, &
    3687             :                                         sphi_b, &
    3688             :                                         sphi_c, &
    3689             :                                         sphi_d, &
    3690             :                                         primitives, &
    3691           0 :                                         buffer1, buffer2)
    3692             : #endif
    3693             :                CASE DEFAULT
    3694             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    3695             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    3696             :                                         sphi_a, &
    3697             :                                         sphi_b, &
    3698             :                                         sphi_c, &
    3699             :                                         sphi_d, &
    3700             :                                         primitives, &
    3701     1879698 :                                         buffer1, buffer2)
    3702             :                END SELECT
    3703             :             CASE (1)
    3704     2006439 :                SELECT CASE (n_d)
    3705             :                CASE (0)
    3706             : #if __MAX_CONTR > 2 || __MAX_CONTR == 2
    3707             :                   CALL contract_pdps(work, &
    3708             :                                      nl_a, nl_b, nl_c, nl_d, &
    3709             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    3710             :                                      primitives, &
    3711      440142 :                                      buffer1, buffer2)
    3712             : #else
    3713             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    3714             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    3715             :                                         sphi_a, &
    3716             :                                         sphi_b, &
    3717             :                                         sphi_c, &
    3718             :                                         sphi_d, &
    3719             :                                         primitives, &
    3720             :                                         buffer1, buffer2)
    3721             : #endif
    3722             :                CASE (1)
    3723             : #if __MAX_CONTR > 2 || __MAX_CONTR == 2
    3724             :                   CALL contract_pdpp(work, &
    3725             :                                      nl_a, nl_b, nl_c, nl_d, &
    3726             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    3727             :                                      primitives, &
    3728      485655 :                                      buffer1, buffer2)
    3729             : #else
    3730             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    3731             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    3732             :                                         sphi_a, &
    3733             :                                         sphi_b, &
    3734             :                                         sphi_c, &
    3735             :                                         sphi_d, &
    3736             :                                         primitives, &
    3737             :                                         buffer1, buffer2)
    3738             : #endif
    3739             :                CASE (2)
    3740             : #if __MAX_CONTR > 2 || __MAX_CONTR == 2
    3741             :                   CALL contract_pdpd(work, &
    3742             :                                      nl_a, nl_b, nl_c, nl_d, &
    3743             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    3744             :                                      primitives, &
    3745      210630 :                                      buffer1, buffer2)
    3746             : #else
    3747             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    3748             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    3749             :                                         sphi_a, &
    3750             :                                         sphi_b, &
    3751             :                                         sphi_c, &
    3752             :                                         sphi_d, &
    3753             :                                         primitives, &
    3754             :                                         buffer1, buffer2)
    3755             : #endif
    3756             :                CASE (3)
    3757             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    3758             :                   CALL contract_pdpf(work, &
    3759             :                                      nl_a, nl_b, nl_c, nl_d, &
    3760             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    3761             :                                      primitives, &
    3762             :                                      buffer1, buffer2)
    3763             : #else
    3764             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    3765             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    3766             :                                         sphi_a, &
    3767             :                                         sphi_b, &
    3768             :                                         sphi_c, &
    3769             :                                         sphi_d, &
    3770             :                                         primitives, &
    3771        2011 :                                         buffer1, buffer2)
    3772             : #endif
    3773             :                CASE (4)
    3774             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    3775             :                   CALL contract_pdpg(work, &
    3776             :                                      nl_a, nl_b, nl_c, nl_d, &
    3777             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    3778             :                                      primitives, &
    3779             :                                      buffer1, buffer2)
    3780             : #else
    3781             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    3782             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    3783             :                                         sphi_a, &
    3784             :                                         sphi_b, &
    3785             :                                         sphi_c, &
    3786             :                                         sphi_d, &
    3787             :                                         primitives, &
    3788           0 :                                         buffer1, buffer2)
    3789             : #endif
    3790             :                CASE DEFAULT
    3791             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    3792             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    3793             :                                         sphi_a, &
    3794             :                                         sphi_b, &
    3795             :                                         sphi_c, &
    3796             :                                         sphi_d, &
    3797             :                                         primitives, &
    3798     1138438 :                                         buffer1, buffer2)
    3799             :                END SELECT
    3800             :             CASE (2)
    3801      625672 :                SELECT CASE (n_d)
    3802             :                CASE (0)
    3803             : #if __MAX_CONTR > 2 || __MAX_CONTR == 2
    3804             :                   CALL contract_pdds(work, &
    3805             :                                      nl_a, nl_b, nl_c, nl_d, &
    3806             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    3807             :                                      primitives, &
    3808      192134 :                                      buffer1, buffer2)
    3809             : #else
    3810             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    3811             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    3812             :                                         sphi_a, &
    3813             :                                         sphi_b, &
    3814             :                                         sphi_c, &
    3815             :                                         sphi_d, &
    3816             :                                         primitives, &
    3817             :                                         buffer1, buffer2)
    3818             : #endif
    3819             :                CASE (1)
    3820             : #if __MAX_CONTR > 2 || __MAX_CONTR == 2
    3821             :                   CALL contract_pddp(work, &
    3822             :                                      nl_a, nl_b, nl_c, nl_d, &
    3823             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    3824             :                                      primitives, &
    3825      129376 :                                      buffer1, buffer2)
    3826             : #else
    3827             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    3828             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    3829             :                                         sphi_a, &
    3830             :                                         sphi_b, &
    3831             :                                         sphi_c, &
    3832             :                                         sphi_d, &
    3833             :                                         primitives, &
    3834             :                                         buffer1, buffer2)
    3835             : #endif
    3836             :                CASE (2)
    3837             : #if __MAX_CONTR > 2 || __MAX_CONTR == 2
    3838             :                   CALL contract_pddd(work, &
    3839             :                                      nl_a, nl_b, nl_c, nl_d, &
    3840             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    3841             :                                      primitives, &
    3842      104299 :                                      buffer1, buffer2)
    3843             : #else
    3844             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    3845             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    3846             :                                         sphi_a, &
    3847             :                                         sphi_b, &
    3848             :                                         sphi_c, &
    3849             :                                         sphi_d, &
    3850             :                                         primitives, &
    3851             :                                         buffer1, buffer2)
    3852             : #endif
    3853             :                CASE (3)
    3854             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    3855             :                   CALL contract_pddf(work, &
    3856             :                                      nl_a, nl_b, nl_c, nl_d, &
    3857             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    3858             :                                      primitives, &
    3859             :                                      buffer1, buffer2)
    3860             : #else
    3861             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    3862             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    3863             :                                         sphi_a, &
    3864             :                                         sphi_b, &
    3865             :                                         sphi_c, &
    3866             :                                         sphi_d, &
    3867             :                                         primitives, &
    3868        2050 :                                         buffer1, buffer2)
    3869             : #endif
    3870             :                CASE (4)
    3871             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    3872             :                   CALL contract_pddg(work, &
    3873             :                                      nl_a, nl_b, nl_c, nl_d, &
    3874             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    3875             :                                      primitives, &
    3876             :                                      buffer1, buffer2)
    3877             : #else
    3878             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    3879             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    3880             :                                         sphi_a, &
    3881             :                                         sphi_b, &
    3882             :                                         sphi_c, &
    3883             :                                         sphi_d, &
    3884             :                                         primitives, &
    3885           0 :                                         buffer1, buffer2)
    3886             : #endif
    3887             :                CASE DEFAULT
    3888             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    3889             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    3890             :                                         sphi_a, &
    3891             :                                         sphi_b, &
    3892             :                                         sphi_c, &
    3893             :                                         sphi_d, &
    3894             :                                         primitives, &
    3895      427859 :                                         buffer1, buffer2)
    3896             :                END SELECT
    3897             :             CASE (3)
    3898        8445 :                SELECT CASE (n_d)
    3899             :                CASE (0)
    3900             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    3901             :                   CALL contract_pdfs(work, &
    3902             :                                      nl_a, nl_b, nl_c, nl_d, &
    3903             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    3904             :                                      primitives, &
    3905             :                                      buffer1, buffer2)
    3906             : #else
    3907             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    3908             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    3909             :                                         sphi_a, &
    3910             :                                         sphi_b, &
    3911             :                                         sphi_c, &
    3912             :                                         sphi_d, &
    3913             :                                         primitives, &
    3914        2766 :                                         buffer1, buffer2)
    3915             : #endif
    3916             :                CASE (1)
    3917             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    3918             :                   CALL contract_pdfp(work, &
    3919             :                                      nl_a, nl_b, nl_c, nl_d, &
    3920             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    3921             :                                      primitives, &
    3922             :                                      buffer1, buffer2)
    3923             : #else
    3924             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    3925             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    3926             :                                         sphi_a, &
    3927             :                                         sphi_b, &
    3928             :                                         sphi_c, &
    3929             :                                         sphi_d, &
    3930             :                                         primitives, &
    3931        1091 :                                         buffer1, buffer2)
    3932             : #endif
    3933             :                CASE (2)
    3934             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    3935             :                   CALL contract_pdfd(work, &
    3936             :                                      nl_a, nl_b, nl_c, nl_d, &
    3937             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    3938             :                                      primitives, &
    3939             :                                      buffer1, buffer2)
    3940             : #else
    3941             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    3942             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    3943             :                                         sphi_a, &
    3944             :                                         sphi_b, &
    3945             :                                         sphi_c, &
    3946             :                                         sphi_d, &
    3947             :                                         primitives, &
    3948        1165 :                                         buffer1, buffer2)
    3949             : #endif
    3950             :                CASE (3)
    3951             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    3952             :                   CALL contract_pdff(work, &
    3953             :                                      nl_a, nl_b, nl_c, nl_d, &
    3954             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    3955             :                                      primitives, &
    3956             :                                      buffer1, buffer2)
    3957             : #else
    3958             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    3959             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    3960             :                                         sphi_a, &
    3961             :                                         sphi_b, &
    3962             :                                         sphi_c, &
    3963             :                                         sphi_d, &
    3964             :                                         primitives, &
    3965         657 :                                         buffer1, buffer2)
    3966             : #endif
    3967             :                CASE (4)
    3968             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    3969             :                   CALL contract_pdfg(work, &
    3970             :                                      nl_a, nl_b, nl_c, nl_d, &
    3971             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    3972             :                                      primitives, &
    3973             :                                      buffer1, buffer2)
    3974             : #else
    3975             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    3976             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    3977             :                                         sphi_a, &
    3978             :                                         sphi_b, &
    3979             :                                         sphi_c, &
    3980             :                                         sphi_d, &
    3981             :                                         primitives, &
    3982           0 :                                         buffer1, buffer2)
    3983             : #endif
    3984             :                CASE DEFAULT
    3985             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    3986             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    3987             :                                         sphi_a, &
    3988             :                                         sphi_b, &
    3989             :                                         sphi_c, &
    3990             :                                         sphi_d, &
    3991             :                                         primitives, &
    3992        5679 :                                         buffer1, buffer2)
    3993             :                END SELECT
    3994             :             CASE (4)
    3995           0 :                SELECT CASE (n_d)
    3996             :                CASE (0)
    3997             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    3998             :                   CALL contract_pdgs(work, &
    3999             :                                      nl_a, nl_b, nl_c, nl_d, &
    4000             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    4001             :                                      primitives, &
    4002             :                                      buffer1, buffer2)
    4003             : #else
    4004             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    4005             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    4006             :                                         sphi_a, &
    4007             :                                         sphi_b, &
    4008             :                                         sphi_c, &
    4009             :                                         sphi_d, &
    4010             :                                         primitives, &
    4011           0 :                                         buffer1, buffer2)
    4012             : #endif
    4013             :                CASE (1)
    4014             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    4015             :                   CALL contract_pdgp(work, &
    4016             :                                      nl_a, nl_b, nl_c, nl_d, &
    4017             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    4018             :                                      primitives, &
    4019             :                                      buffer1, buffer2)
    4020             : #else
    4021             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    4022             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    4023             :                                         sphi_a, &
    4024             :                                         sphi_b, &
    4025             :                                         sphi_c, &
    4026             :                                         sphi_d, &
    4027             :                                         primitives, &
    4028           0 :                                         buffer1, buffer2)
    4029             : #endif
    4030             :                CASE (2)
    4031             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    4032             :                   CALL contract_pdgd(work, &
    4033             :                                      nl_a, nl_b, nl_c, nl_d, &
    4034             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    4035             :                                      primitives, &
    4036             :                                      buffer1, buffer2)
    4037             : #else
    4038             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    4039             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    4040             :                                         sphi_a, &
    4041             :                                         sphi_b, &
    4042             :                                         sphi_c, &
    4043             :                                         sphi_d, &
    4044             :                                         primitives, &
    4045           0 :                                         buffer1, buffer2)
    4046             : #endif
    4047             :                CASE (3)
    4048             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    4049             :                   CALL contract_pdgf(work, &
    4050             :                                      nl_a, nl_b, nl_c, nl_d, &
    4051             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    4052             :                                      primitives, &
    4053             :                                      buffer1, buffer2)
    4054             : #else
    4055             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    4056             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    4057             :                                         sphi_a, &
    4058             :                                         sphi_b, &
    4059             :                                         sphi_c, &
    4060             :                                         sphi_d, &
    4061             :                                         primitives, &
    4062           0 :                                         buffer1, buffer2)
    4063             : #endif
    4064             :                CASE (4)
    4065             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    4066             :                   CALL contract_pdgg(work, &
    4067             :                                      nl_a, nl_b, nl_c, nl_d, &
    4068             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    4069             :                                      primitives, &
    4070             :                                      buffer1, buffer2)
    4071             : #else
    4072             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    4073             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    4074             :                                         sphi_a, &
    4075             :                                         sphi_b, &
    4076             :                                         sphi_c, &
    4077             :                                         sphi_d, &
    4078             :                                         primitives, &
    4079           0 :                                         buffer1, buffer2)
    4080             : #endif
    4081             :                CASE DEFAULT
    4082             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    4083             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    4084             :                                         sphi_a, &
    4085             :                                         sphi_b, &
    4086             :                                         sphi_c, &
    4087             :                                         sphi_d, &
    4088             :                                         primitives, &
    4089           0 :                                         buffer1, buffer2)
    4090             :                END SELECT
    4091             :             CASE DEFAULT
    4092             :                CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    4093             :                                      work, nl_a, nl_b, nl_c, nl_d, &
    4094             :                                      sphi_a, &
    4095             :                                      sphi_b, &
    4096             :                                      sphi_c, &
    4097             :                                      sphi_d, &
    4098             :                                      primitives, &
    4099     3451674 :                                      buffer1, buffer2)
    4100             :             END SELECT
    4101             :          CASE (3)
    4102       94727 :             SELECT CASE (n_c)
    4103             :             CASE (0)
    4104       72468 :                SELECT CASE (n_d)
    4105             :                CASE (0)
    4106             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    4107             :                   CALL contract_pfss(work, &
    4108             :                                      nl_a, nl_b, nl_c, nl_d, &
    4109             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    4110             :                                      primitives, &
    4111             :                                      buffer1, buffer2)
    4112             : #else
    4113             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    4114             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    4115             :                                         sphi_a, &
    4116             :                                         sphi_b, &
    4117             :                                         sphi_c, &
    4118             :                                         sphi_d, &
    4119             :                                         primitives, &
    4120       22676 :                                         buffer1, buffer2)
    4121             : #endif
    4122             :                CASE (1)
    4123             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    4124             :                   CALL contract_pfsp(work, &
    4125             :                                      nl_a, nl_b, nl_c, nl_d, &
    4126             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    4127             :                                      primitives, &
    4128             :                                      buffer1, buffer2)
    4129             : #else
    4130             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    4131             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    4132             :                                         sphi_a, &
    4133             :                                         sphi_b, &
    4134             :                                         sphi_c, &
    4135             :                                         sphi_d, &
    4136             :                                         primitives, &
    4137        4977 :                                         buffer1, buffer2)
    4138             : #endif
    4139             :                CASE (2)
    4140             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    4141             :                   CALL contract_pfsd(work, &
    4142             :                                      nl_a, nl_b, nl_c, nl_d, &
    4143             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    4144             :                                      primitives, &
    4145             :                                      buffer1, buffer2)
    4146             : #else
    4147             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    4148             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    4149             :                                         sphi_a, &
    4150             :                                         sphi_b, &
    4151             :                                         sphi_c, &
    4152             :                                         sphi_d, &
    4153             :                                         primitives, &
    4154        6185 :                                         buffer1, buffer2)
    4155             : #endif
    4156             :                CASE (3)
    4157             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    4158             :                   CALL contract_pfsf(work, &
    4159             :                                      nl_a, nl_b, nl_c, nl_d, &
    4160             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    4161             :                                      primitives, &
    4162             :                                      buffer1, buffer2)
    4163             : #else
    4164             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    4165             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    4166             :                                         sphi_a, &
    4167             :                                         sphi_b, &
    4168             :                                         sphi_c, &
    4169             :                                         sphi_d, &
    4170             :                                         primitives, &
    4171        1424 :                                         buffer1, buffer2)
    4172             : #endif
    4173             :                CASE (4)
    4174             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    4175             :                   CALL contract_pfsg(work, &
    4176             :                                      nl_a, nl_b, nl_c, nl_d, &
    4177             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    4178             :                                      primitives, &
    4179             :                                      buffer1, buffer2)
    4180             : #else
    4181             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    4182             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    4183             :                                         sphi_a, &
    4184             :                                         sphi_b, &
    4185             :                                         sphi_c, &
    4186             :                                         sphi_d, &
    4187             :                                         primitives, &
    4188           0 :                                         buffer1, buffer2)
    4189             : #endif
    4190             :                CASE DEFAULT
    4191             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    4192             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    4193             :                                         sphi_a, &
    4194             :                                         sphi_b, &
    4195             :                                         sphi_c, &
    4196             :                                         sphi_d, &
    4197             :                                         primitives, &
    4198       35262 :                                         buffer1, buffer2)
    4199             :                END SELECT
    4200             :             CASE (1)
    4201       24001 :                SELECT CASE (n_d)
    4202             :                CASE (0)
    4203             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    4204             :                   CALL contract_pfps(work, &
    4205             :                                      nl_a, nl_b, nl_c, nl_d, &
    4206             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    4207             :                                      primitives, &
    4208             :                                      buffer1, buffer2)
    4209             : #else
    4210             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    4211             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    4212             :                                         sphi_a, &
    4213             :                                         sphi_b, &
    4214             :                                         sphi_c, &
    4215             :                                         sphi_d, &
    4216             :                                         primitives, &
    4217        2714 :                                         buffer1, buffer2)
    4218             : #endif
    4219             :                CASE (1)
    4220             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    4221             :                   CALL contract_pfpp(work, &
    4222             :                                      nl_a, nl_b, nl_c, nl_d, &
    4223             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    4224             :                                      primitives, &
    4225             :                                      buffer1, buffer2)
    4226             : #else
    4227             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    4228             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    4229             :                                         sphi_a, &
    4230             :                                         sphi_b, &
    4231             :                                         sphi_c, &
    4232             :                                         sphi_d, &
    4233             :                                         primitives, &
    4234        7571 :                                         buffer1, buffer2)
    4235             : #endif
    4236             :                CASE (2)
    4237             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    4238             :                   CALL contract_pfpd(work, &
    4239             :                                      nl_a, nl_b, nl_c, nl_d, &
    4240             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    4241             :                                      primitives, &
    4242             :                                      buffer1, buffer2)
    4243             : #else
    4244             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    4245             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    4246             :                                         sphi_a, &
    4247             :                                         sphi_b, &
    4248             :                                         sphi_c, &
    4249             :                                         sphi_d, &
    4250             :                                         primitives, &
    4251        1925 :                                         buffer1, buffer2)
    4252             : #endif
    4253             :                CASE (3)
    4254             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    4255             :                   CALL contract_pfpf(work, &
    4256             :                                      nl_a, nl_b, nl_c, nl_d, &
    4257             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    4258             :                                      primitives, &
    4259             :                                      buffer1, buffer2)
    4260             : #else
    4261             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    4262             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    4263             :                                         sphi_a, &
    4264             :                                         sphi_b, &
    4265             :                                         sphi_c, &
    4266             :                                         sphi_d, &
    4267             :                                         primitives, &
    4268        2320 :                                         buffer1, buffer2)
    4269             : #endif
    4270             :                CASE (4)
    4271             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    4272             :                   CALL contract_pfpg(work, &
    4273             :                                      nl_a, nl_b, nl_c, nl_d, &
    4274             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    4275             :                                      primitives, &
    4276             :                                      buffer1, buffer2)
    4277             : #else
    4278             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    4279             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    4280             :                                         sphi_a, &
    4281             :                                         sphi_b, &
    4282             :                                         sphi_c, &
    4283             :                                         sphi_d, &
    4284             :                                         primitives, &
    4285           0 :                                         buffer1, buffer2)
    4286             : #endif
    4287             :                CASE DEFAULT
    4288             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    4289             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    4290             :                                         sphi_a, &
    4291             :                                         sphi_b, &
    4292             :                                         sphi_c, &
    4293             :                                         sphi_d, &
    4294             :                                         primitives, &
    4295       14530 :                                         buffer1, buffer2)
    4296             :                END SELECT
    4297             :             CASE (2)
    4298       12877 :                SELECT CASE (n_d)
    4299             :                CASE (0)
    4300             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    4301             :                   CALL contract_pfds(work, &
    4302             :                                      nl_a, nl_b, nl_c, nl_d, &
    4303             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    4304             :                                      primitives, &
    4305             :                                      buffer1, buffer2)
    4306             : #else
    4307             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    4308             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    4309             :                                         sphi_a, &
    4310             :                                         sphi_b, &
    4311             :                                         sphi_c, &
    4312             :                                         sphi_d, &
    4313             :                                         primitives, &
    4314        3204 :                                         buffer1, buffer2)
    4315             : #endif
    4316             :                CASE (1)
    4317             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    4318             :                   CALL contract_pfdp(work, &
    4319             :                                      nl_a, nl_b, nl_c, nl_d, &
    4320             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    4321             :                                      primitives, &
    4322             :                                      buffer1, buffer2)
    4323             : #else
    4324             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    4325             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    4326             :                                         sphi_a, &
    4327             :                                         sphi_b, &
    4328             :                                         sphi_c, &
    4329             :                                         sphi_d, &
    4330             :                                         primitives, &
    4331        1111 :                                         buffer1, buffer2)
    4332             : #endif
    4333             :                CASE (2)
    4334             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    4335             :                   CALL contract_pfdd(work, &
    4336             :                                      nl_a, nl_b, nl_c, nl_d, &
    4337             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    4338             :                                      primitives, &
    4339             :                                      buffer1, buffer2)
    4340             : #else
    4341             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    4342             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    4343             :                                         sphi_a, &
    4344             :                                         sphi_b, &
    4345             :                                         sphi_c, &
    4346             :                                         sphi_d, &
    4347             :                                         primitives, &
    4348        1799 :                                         buffer1, buffer2)
    4349             : #endif
    4350             :                CASE (3)
    4351             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    4352             :                   CALL contract_pfdf(work, &
    4353             :                                      nl_a, nl_b, nl_c, nl_d, &
    4354             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    4355             :                                      primitives, &
    4356             :                                      buffer1, buffer2)
    4357             : #else
    4358             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    4359             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    4360             :                                         sphi_a, &
    4361             :                                         sphi_b, &
    4362             :                                         sphi_c, &
    4363             :                                         sphi_d, &
    4364             :                                         primitives, &
    4365         643 :                                         buffer1, buffer2)
    4366             : #endif
    4367             :                CASE (4)
    4368             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    4369             :                   CALL contract_pfdg(work, &
    4370             :                                      nl_a, nl_b, nl_c, nl_d, &
    4371             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    4372             :                                      primitives, &
    4373             :                                      buffer1, buffer2)
    4374             : #else
    4375             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    4376             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    4377             :                                         sphi_a, &
    4378             :                                         sphi_b, &
    4379             :                                         sphi_c, &
    4380             :                                         sphi_d, &
    4381             :                                         primitives, &
    4382           0 :                                         buffer1, buffer2)
    4383             : #endif
    4384             :                CASE DEFAULT
    4385             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    4386             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    4387             :                                         sphi_a, &
    4388             :                                         sphi_b, &
    4389             :                                         sphi_c, &
    4390             :                                         sphi_d, &
    4391             :                                         primitives, &
    4392        6757 :                                         buffer1, buffer2)
    4393             :                END SELECT
    4394             :             CASE (3)
    4395        3563 :                SELECT CASE (n_d)
    4396             :                CASE (0)
    4397             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    4398             :                   CALL contract_pffs(work, &
    4399             :                                      nl_a, nl_b, nl_c, nl_d, &
    4400             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    4401             :                                      primitives, &
    4402             :                                      buffer1, buffer2)
    4403             : #else
    4404             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    4405             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    4406             :                                         sphi_a, &
    4407             :                                         sphi_b, &
    4408             :                                         sphi_c, &
    4409             :                                         sphi_d, &
    4410             :                                         primitives, &
    4411         647 :                                         buffer1, buffer2)
    4412             : #endif
    4413             :                CASE (1)
    4414             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    4415             :                   CALL contract_pffp(work, &
    4416             :                                      nl_a, nl_b, nl_c, nl_d, &
    4417             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    4418             :                                      primitives, &
    4419             :                                      buffer1, buffer2)
    4420             : #else
    4421             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    4422             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    4423             :                                         sphi_a, &
    4424             :                                         sphi_b, &
    4425             :                                         sphi_c, &
    4426             :                                         sphi_d, &
    4427             :                                         primitives, &
    4428        1175 :                                         buffer1, buffer2)
    4429             : #endif
    4430             :                CASE (2)
    4431             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    4432             :                   CALL contract_pffd(work, &
    4433             :                                      nl_a, nl_b, nl_c, nl_d, &
    4434             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    4435             :                                      primitives, &
    4436             :                                      buffer1, buffer2)
    4437             : #else
    4438             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    4439             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    4440             :                                         sphi_a, &
    4441             :                                         sphi_b, &
    4442             :                                         sphi_c, &
    4443             :                                         sphi_d, &
    4444             :                                         primitives, &
    4445         388 :                                         buffer1, buffer2)
    4446             : #endif
    4447             :                CASE (3)
    4448             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    4449             :                   CALL contract_pfff(work, &
    4450             :                                      nl_a, nl_b, nl_c, nl_d, &
    4451             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    4452             :                                      primitives, &
    4453             :                                      buffer1, buffer2)
    4454             : #else
    4455             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    4456             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    4457             :                                         sphi_a, &
    4458             :                                         sphi_b, &
    4459             :                                         sphi_c, &
    4460             :                                         sphi_d, &
    4461             :                                         primitives, &
    4462         706 :                                         buffer1, buffer2)
    4463             : #endif
    4464             :                CASE (4)
    4465             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    4466             :                   CALL contract_pffg(work, &
    4467             :                                      nl_a, nl_b, nl_c, nl_d, &
    4468             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    4469             :                                      primitives, &
    4470             :                                      buffer1, buffer2)
    4471             : #else
    4472             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    4473             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    4474             :                                         sphi_a, &
    4475             :                                         sphi_b, &
    4476             :                                         sphi_c, &
    4477             :                                         sphi_d, &
    4478             :                                         primitives, &
    4479           0 :                                         buffer1, buffer2)
    4480             : #endif
    4481             :                CASE DEFAULT
    4482             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    4483             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    4484             :                                         sphi_a, &
    4485             :                                         sphi_b, &
    4486             :                                         sphi_c, &
    4487             :                                         sphi_d, &
    4488             :                                         primitives, &
    4489        2916 :                                         buffer1, buffer2)
    4490             :                END SELECT
    4491             :             CASE (4)
    4492           0 :                SELECT CASE (n_d)
    4493             :                CASE (0)
    4494             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    4495             :                   CALL contract_pfgs(work, &
    4496             :                                      nl_a, nl_b, nl_c, nl_d, &
    4497             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    4498             :                                      primitives, &
    4499             :                                      buffer1, buffer2)
    4500             : #else
    4501             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    4502             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    4503             :                                         sphi_a, &
    4504             :                                         sphi_b, &
    4505             :                                         sphi_c, &
    4506             :                                         sphi_d, &
    4507             :                                         primitives, &
    4508           0 :                                         buffer1, buffer2)
    4509             : #endif
    4510             :                CASE (1)
    4511             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    4512             :                   CALL contract_pfgp(work, &
    4513             :                                      nl_a, nl_b, nl_c, nl_d, &
    4514             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    4515             :                                      primitives, &
    4516             :                                      buffer1, buffer2)
    4517             : #else
    4518             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    4519             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    4520             :                                         sphi_a, &
    4521             :                                         sphi_b, &
    4522             :                                         sphi_c, &
    4523             :                                         sphi_d, &
    4524             :                                         primitives, &
    4525           0 :                                         buffer1, buffer2)
    4526             : #endif
    4527             :                CASE (2)
    4528             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    4529             :                   CALL contract_pfgd(work, &
    4530             :                                      nl_a, nl_b, nl_c, nl_d, &
    4531             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    4532             :                                      primitives, &
    4533             :                                      buffer1, buffer2)
    4534             : #else
    4535             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    4536             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    4537             :                                         sphi_a, &
    4538             :                                         sphi_b, &
    4539             :                                         sphi_c, &
    4540             :                                         sphi_d, &
    4541             :                                         primitives, &
    4542           0 :                                         buffer1, buffer2)
    4543             : #endif
    4544             :                CASE (3)
    4545             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    4546             :                   CALL contract_pfgf(work, &
    4547             :                                      nl_a, nl_b, nl_c, nl_d, &
    4548             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    4549             :                                      primitives, &
    4550             :                                      buffer1, buffer2)
    4551             : #else
    4552             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    4553             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    4554             :                                         sphi_a, &
    4555             :                                         sphi_b, &
    4556             :                                         sphi_c, &
    4557             :                                         sphi_d, &
    4558             :                                         primitives, &
    4559           0 :                                         buffer1, buffer2)
    4560             : #endif
    4561             :                CASE (4)
    4562             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    4563             :                   CALL contract_pfgg(work, &
    4564             :                                      nl_a, nl_b, nl_c, nl_d, &
    4565             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    4566             :                                      primitives, &
    4567             :                                      buffer1, buffer2)
    4568             : #else
    4569             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    4570             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    4571             :                                         sphi_a, &
    4572             :                                         sphi_b, &
    4573             :                                         sphi_c, &
    4574             :                                         sphi_d, &
    4575             :                                         primitives, &
    4576           0 :                                         buffer1, buffer2)
    4577             : #endif
    4578             :                CASE DEFAULT
    4579             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    4580             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    4581             :                                         sphi_a, &
    4582             :                                         sphi_b, &
    4583             :                                         sphi_c, &
    4584             :                                         sphi_d, &
    4585             :                                         primitives, &
    4586           0 :                                         buffer1, buffer2)
    4587             :                END SELECT
    4588             :             CASE DEFAULT
    4589             :                CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    4590             :                                      work, nl_a, nl_b, nl_c, nl_d, &
    4591             :                                      sphi_a, &
    4592             :                                      sphi_b, &
    4593             :                                      sphi_c, &
    4594             :                                      sphi_d, &
    4595             :                                      primitives, &
    4596       59465 :                                      buffer1, buffer2)
    4597             :             END SELECT
    4598             :          CASE (4)
    4599           0 :             SELECT CASE (n_c)
    4600             :             CASE (0)
    4601           0 :                SELECT CASE (n_d)
    4602             :                CASE (0)
    4603             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    4604             :                   CALL contract_pgss(work, &
    4605             :                                      nl_a, nl_b, nl_c, nl_d, &
    4606             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    4607             :                                      primitives, &
    4608             :                                      buffer1, buffer2)
    4609             : #else
    4610             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    4611             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    4612             :                                         sphi_a, &
    4613             :                                         sphi_b, &
    4614             :                                         sphi_c, &
    4615             :                                         sphi_d, &
    4616             :                                         primitives, &
    4617           0 :                                         buffer1, buffer2)
    4618             : #endif
    4619             :                CASE (1)
    4620             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    4621             :                   CALL contract_pgsp(work, &
    4622             :                                      nl_a, nl_b, nl_c, nl_d, &
    4623             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    4624             :                                      primitives, &
    4625             :                                      buffer1, buffer2)
    4626             : #else
    4627             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    4628             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    4629             :                                         sphi_a, &
    4630             :                                         sphi_b, &
    4631             :                                         sphi_c, &
    4632             :                                         sphi_d, &
    4633             :                                         primitives, &
    4634           0 :                                         buffer1, buffer2)
    4635             : #endif
    4636             :                CASE (2)
    4637             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    4638             :                   CALL contract_pgsd(work, &
    4639             :                                      nl_a, nl_b, nl_c, nl_d, &
    4640             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    4641             :                                      primitives, &
    4642             :                                      buffer1, buffer2)
    4643             : #else
    4644             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    4645             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    4646             :                                         sphi_a, &
    4647             :                                         sphi_b, &
    4648             :                                         sphi_c, &
    4649             :                                         sphi_d, &
    4650             :                                         primitives, &
    4651           0 :                                         buffer1, buffer2)
    4652             : #endif
    4653             :                CASE (3)
    4654             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    4655             :                   CALL contract_pgsf(work, &
    4656             :                                      nl_a, nl_b, nl_c, nl_d, &
    4657             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    4658             :                                      primitives, &
    4659             :                                      buffer1, buffer2)
    4660             : #else
    4661             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    4662             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    4663             :                                         sphi_a, &
    4664             :                                         sphi_b, &
    4665             :                                         sphi_c, &
    4666             :                                         sphi_d, &
    4667             :                                         primitives, &
    4668           0 :                                         buffer1, buffer2)
    4669             : #endif
    4670             :                CASE (4)
    4671             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    4672             :                   CALL contract_pgsg(work, &
    4673             :                                      nl_a, nl_b, nl_c, nl_d, &
    4674             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    4675             :                                      primitives, &
    4676             :                                      buffer1, buffer2)
    4677             : #else
    4678             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    4679             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    4680             :                                         sphi_a, &
    4681             :                                         sphi_b, &
    4682             :                                         sphi_c, &
    4683             :                                         sphi_d, &
    4684             :                                         primitives, &
    4685           0 :                                         buffer1, buffer2)
    4686             : #endif
    4687             :                CASE DEFAULT
    4688             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    4689             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    4690             :                                         sphi_a, &
    4691             :                                         sphi_b, &
    4692             :                                         sphi_c, &
    4693             :                                         sphi_d, &
    4694             :                                         primitives, &
    4695           0 :                                         buffer1, buffer2)
    4696             :                END SELECT
    4697             :             CASE (1)
    4698           0 :                SELECT CASE (n_d)
    4699             :                CASE (0)
    4700             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    4701             :                   CALL contract_pgps(work, &
    4702             :                                      nl_a, nl_b, nl_c, nl_d, &
    4703             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    4704             :                                      primitives, &
    4705             :                                      buffer1, buffer2)
    4706             : #else
    4707             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    4708             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    4709             :                                         sphi_a, &
    4710             :                                         sphi_b, &
    4711             :                                         sphi_c, &
    4712             :                                         sphi_d, &
    4713             :                                         primitives, &
    4714           0 :                                         buffer1, buffer2)
    4715             : #endif
    4716             :                CASE (1)
    4717             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    4718             :                   CALL contract_pgpp(work, &
    4719             :                                      nl_a, nl_b, nl_c, nl_d, &
    4720             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    4721             :                                      primitives, &
    4722             :                                      buffer1, buffer2)
    4723             : #else
    4724             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    4725             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    4726             :                                         sphi_a, &
    4727             :                                         sphi_b, &
    4728             :                                         sphi_c, &
    4729             :                                         sphi_d, &
    4730             :                                         primitives, &
    4731           0 :                                         buffer1, buffer2)
    4732             : #endif
    4733             :                CASE (2)
    4734             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    4735             :                   CALL contract_pgpd(work, &
    4736             :                                      nl_a, nl_b, nl_c, nl_d, &
    4737             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    4738             :                                      primitives, &
    4739             :                                      buffer1, buffer2)
    4740             : #else
    4741             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    4742             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    4743             :                                         sphi_a, &
    4744             :                                         sphi_b, &
    4745             :                                         sphi_c, &
    4746             :                                         sphi_d, &
    4747             :                                         primitives, &
    4748           0 :                                         buffer1, buffer2)
    4749             : #endif
    4750             :                CASE (3)
    4751             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    4752             :                   CALL contract_pgpf(work, &
    4753             :                                      nl_a, nl_b, nl_c, nl_d, &
    4754             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    4755             :                                      primitives, &
    4756             :                                      buffer1, buffer2)
    4757             : #else
    4758             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    4759             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    4760             :                                         sphi_a, &
    4761             :                                         sphi_b, &
    4762             :                                         sphi_c, &
    4763             :                                         sphi_d, &
    4764             :                                         primitives, &
    4765           0 :                                         buffer1, buffer2)
    4766             : #endif
    4767             :                CASE (4)
    4768             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    4769             :                   CALL contract_pgpg(work, &
    4770             :                                      nl_a, nl_b, nl_c, nl_d, &
    4771             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    4772             :                                      primitives, &
    4773             :                                      buffer1, buffer2)
    4774             : #else
    4775             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    4776             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    4777             :                                         sphi_a, &
    4778             :                                         sphi_b, &
    4779             :                                         sphi_c, &
    4780             :                                         sphi_d, &
    4781             :                                         primitives, &
    4782           0 :                                         buffer1, buffer2)
    4783             : #endif
    4784             :                CASE DEFAULT
    4785             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    4786             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    4787             :                                         sphi_a, &
    4788             :                                         sphi_b, &
    4789             :                                         sphi_c, &
    4790             :                                         sphi_d, &
    4791             :                                         primitives, &
    4792           0 :                                         buffer1, buffer2)
    4793             :                END SELECT
    4794             :             CASE (2)
    4795           0 :                SELECT CASE (n_d)
    4796             :                CASE (0)
    4797             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    4798             :                   CALL contract_pgds(work, &
    4799             :                                      nl_a, nl_b, nl_c, nl_d, &
    4800             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    4801             :                                      primitives, &
    4802             :                                      buffer1, buffer2)
    4803             : #else
    4804             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    4805             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    4806             :                                         sphi_a, &
    4807             :                                         sphi_b, &
    4808             :                                         sphi_c, &
    4809             :                                         sphi_d, &
    4810             :                                         primitives, &
    4811           0 :                                         buffer1, buffer2)
    4812             : #endif
    4813             :                CASE (1)
    4814             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    4815             :                   CALL contract_pgdp(work, &
    4816             :                                      nl_a, nl_b, nl_c, nl_d, &
    4817             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    4818             :                                      primitives, &
    4819             :                                      buffer1, buffer2)
    4820             : #else
    4821             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    4822             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    4823             :                                         sphi_a, &
    4824             :                                         sphi_b, &
    4825             :                                         sphi_c, &
    4826             :                                         sphi_d, &
    4827             :                                         primitives, &
    4828           0 :                                         buffer1, buffer2)
    4829             : #endif
    4830             :                CASE (2)
    4831             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    4832             :                   CALL contract_pgdd(work, &
    4833             :                                      nl_a, nl_b, nl_c, nl_d, &
    4834             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    4835             :                                      primitives, &
    4836             :                                      buffer1, buffer2)
    4837             : #else
    4838             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    4839             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    4840             :                                         sphi_a, &
    4841             :                                         sphi_b, &
    4842             :                                         sphi_c, &
    4843             :                                         sphi_d, &
    4844             :                                         primitives, &
    4845           0 :                                         buffer1, buffer2)
    4846             : #endif
    4847             :                CASE (3)
    4848             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    4849             :                   CALL contract_pgdf(work, &
    4850             :                                      nl_a, nl_b, nl_c, nl_d, &
    4851             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    4852             :                                      primitives, &
    4853             :                                      buffer1, buffer2)
    4854             : #else
    4855             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    4856             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    4857             :                                         sphi_a, &
    4858             :                                         sphi_b, &
    4859             :                                         sphi_c, &
    4860             :                                         sphi_d, &
    4861             :                                         primitives, &
    4862           0 :                                         buffer1, buffer2)
    4863             : #endif
    4864             :                CASE (4)
    4865             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    4866             :                   CALL contract_pgdg(work, &
    4867             :                                      nl_a, nl_b, nl_c, nl_d, &
    4868             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    4869             :                                      primitives, &
    4870             :                                      buffer1, buffer2)
    4871             : #else
    4872             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    4873             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    4874             :                                         sphi_a, &
    4875             :                                         sphi_b, &
    4876             :                                         sphi_c, &
    4877             :                                         sphi_d, &
    4878             :                                         primitives, &
    4879           0 :                                         buffer1, buffer2)
    4880             : #endif
    4881             :                CASE DEFAULT
    4882             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    4883             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    4884             :                                         sphi_a, &
    4885             :                                         sphi_b, &
    4886             :                                         sphi_c, &
    4887             :                                         sphi_d, &
    4888             :                                         primitives, &
    4889           0 :                                         buffer1, buffer2)
    4890             :                END SELECT
    4891             :             CASE (3)
    4892           0 :                SELECT CASE (n_d)
    4893             :                CASE (0)
    4894             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    4895             :                   CALL contract_pgfs(work, &
    4896             :                                      nl_a, nl_b, nl_c, nl_d, &
    4897             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    4898             :                                      primitives, &
    4899             :                                      buffer1, buffer2)
    4900             : #else
    4901             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    4902             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    4903             :                                         sphi_a, &
    4904             :                                         sphi_b, &
    4905             :                                         sphi_c, &
    4906             :                                         sphi_d, &
    4907             :                                         primitives, &
    4908           0 :                                         buffer1, buffer2)
    4909             : #endif
    4910             :                CASE (1)
    4911             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    4912             :                   CALL contract_pgfp(work, &
    4913             :                                      nl_a, nl_b, nl_c, nl_d, &
    4914             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    4915             :                                      primitives, &
    4916             :                                      buffer1, buffer2)
    4917             : #else
    4918             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    4919             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    4920             :                                         sphi_a, &
    4921             :                                         sphi_b, &
    4922             :                                         sphi_c, &
    4923             :                                         sphi_d, &
    4924             :                                         primitives, &
    4925           0 :                                         buffer1, buffer2)
    4926             : #endif
    4927             :                CASE (2)
    4928             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    4929             :                   CALL contract_pgfd(work, &
    4930             :                                      nl_a, nl_b, nl_c, nl_d, &
    4931             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    4932             :                                      primitives, &
    4933             :                                      buffer1, buffer2)
    4934             : #else
    4935             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    4936             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    4937             :                                         sphi_a, &
    4938             :                                         sphi_b, &
    4939             :                                         sphi_c, &
    4940             :                                         sphi_d, &
    4941             :                                         primitives, &
    4942           0 :                                         buffer1, buffer2)
    4943             : #endif
    4944             :                CASE (3)
    4945             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    4946             :                   CALL contract_pgff(work, &
    4947             :                                      nl_a, nl_b, nl_c, nl_d, &
    4948             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    4949             :                                      primitives, &
    4950             :                                      buffer1, buffer2)
    4951             : #else
    4952             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    4953             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    4954             :                                         sphi_a, &
    4955             :                                         sphi_b, &
    4956             :                                         sphi_c, &
    4957             :                                         sphi_d, &
    4958             :                                         primitives, &
    4959           0 :                                         buffer1, buffer2)
    4960             : #endif
    4961             :                CASE (4)
    4962             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    4963             :                   CALL contract_pgfg(work, &
    4964             :                                      nl_a, nl_b, nl_c, nl_d, &
    4965             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    4966             :                                      primitives, &
    4967             :                                      buffer1, buffer2)
    4968             : #else
    4969             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    4970             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    4971             :                                         sphi_a, &
    4972             :                                         sphi_b, &
    4973             :                                         sphi_c, &
    4974             :                                         sphi_d, &
    4975             :                                         primitives, &
    4976           0 :                                         buffer1, buffer2)
    4977             : #endif
    4978             :                CASE DEFAULT
    4979             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    4980             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    4981             :                                         sphi_a, &
    4982             :                                         sphi_b, &
    4983             :                                         sphi_c, &
    4984             :                                         sphi_d, &
    4985             :                                         primitives, &
    4986           0 :                                         buffer1, buffer2)
    4987             :                END SELECT
    4988             :             CASE (4)
    4989           0 :                SELECT CASE (n_d)
    4990             :                CASE (0)
    4991             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    4992             :                   CALL contract_pggs(work, &
    4993             :                                      nl_a, nl_b, nl_c, nl_d, &
    4994             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    4995             :                                      primitives, &
    4996             :                                      buffer1, buffer2)
    4997             : #else
    4998             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    4999             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    5000             :                                         sphi_a, &
    5001             :                                         sphi_b, &
    5002             :                                         sphi_c, &
    5003             :                                         sphi_d, &
    5004             :                                         primitives, &
    5005           0 :                                         buffer1, buffer2)
    5006             : #endif
    5007             :                CASE (1)
    5008             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    5009             :                   CALL contract_pggp(work, &
    5010             :                                      nl_a, nl_b, nl_c, nl_d, &
    5011             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    5012             :                                      primitives, &
    5013             :                                      buffer1, buffer2)
    5014             : #else
    5015             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    5016             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    5017             :                                         sphi_a, &
    5018             :                                         sphi_b, &
    5019             :                                         sphi_c, &
    5020             :                                         sphi_d, &
    5021             :                                         primitives, &
    5022           0 :                                         buffer1, buffer2)
    5023             : #endif
    5024             :                CASE (2)
    5025             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    5026             :                   CALL contract_pggd(work, &
    5027             :                                      nl_a, nl_b, nl_c, nl_d, &
    5028             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    5029             :                                      primitives, &
    5030             :                                      buffer1, buffer2)
    5031             : #else
    5032             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    5033             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    5034             :                                         sphi_a, &
    5035             :                                         sphi_b, &
    5036             :                                         sphi_c, &
    5037             :                                         sphi_d, &
    5038             :                                         primitives, &
    5039           0 :                                         buffer1, buffer2)
    5040             : #endif
    5041             :                CASE (3)
    5042             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    5043             :                   CALL contract_pggf(work, &
    5044             :                                      nl_a, nl_b, nl_c, nl_d, &
    5045             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    5046             :                                      primitives, &
    5047             :                                      buffer1, buffer2)
    5048             : #else
    5049             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    5050             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    5051             :                                         sphi_a, &
    5052             :                                         sphi_b, &
    5053             :                                         sphi_c, &
    5054             :                                         sphi_d, &
    5055             :                                         primitives, &
    5056           0 :                                         buffer1, buffer2)
    5057             : #endif
    5058             :                CASE (4)
    5059             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    5060             :                   CALL contract_pggg(work, &
    5061             :                                      nl_a, nl_b, nl_c, nl_d, &
    5062             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    5063             :                                      primitives, &
    5064             :                                      buffer1, buffer2)
    5065             : #else
    5066             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    5067             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    5068             :                                         sphi_a, &
    5069             :                                         sphi_b, &
    5070             :                                         sphi_c, &
    5071             :                                         sphi_d, &
    5072             :                                         primitives, &
    5073           0 :                                         buffer1, buffer2)
    5074             : #endif
    5075             :                CASE DEFAULT
    5076             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    5077             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    5078             :                                         sphi_a, &
    5079             :                                         sphi_b, &
    5080             :                                         sphi_c, &
    5081             :                                         sphi_d, &
    5082             :                                         primitives, &
    5083           0 :                                         buffer1, buffer2)
    5084             :                END SELECT
    5085             :             CASE DEFAULT
    5086             :                CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    5087             :                                      work, nl_a, nl_b, nl_c, nl_d, &
    5088             :                                      sphi_a, &
    5089             :                                      sphi_b, &
    5090             :                                      sphi_c, &
    5091             :                                      sphi_d, &
    5092             :                                      primitives, &
    5093           0 :                                      buffer1, buffer2)
    5094             :             END SELECT
    5095             :          CASE DEFAULT
    5096             :             CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    5097             :                                   work, nl_a, nl_b, nl_c, nl_d, &
    5098             :                                   sphi_a, &
    5099             :                                   sphi_b, &
    5100             :                                   sphi_c, &
    5101             :                                   sphi_d, &
    5102             :                                   primitives, &
    5103    99105083 :                                   buffer1, buffer2)
    5104             :          END SELECT
    5105             :       CASE (2)
    5106    24211413 :          SELECT CASE (n_b)
    5107             :          CASE (0)
    5108    17671686 :             SELECT CASE (n_c)
    5109             :             CASE (0)
    5110    10961125 :                SELECT CASE (n_d)
    5111             :                CASE (0)
    5112             : #if __MAX_CONTR > 2 || __MAX_CONTR == 2
    5113             :                   CALL contract_dsss(work, &
    5114             :                                      nl_a, nl_b, nl_c, nl_d, &
    5115             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    5116             :                                      primitives, &
    5117     2815605 :                                      buffer1, buffer2)
    5118             : #else
    5119             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    5120             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    5121             :                                         sphi_a, &
    5122             :                                         sphi_b, &
    5123             :                                         sphi_c, &
    5124             :                                         sphi_d, &
    5125             :                                         primitives, &
    5126             :                                         buffer1, buffer2)
    5127             : #endif
    5128             :                CASE (1)
    5129             : #if __MAX_CONTR > 2 || __MAX_CONTR == 2
    5130             :                   CALL contract_dssp(work, &
    5131             :                                      nl_a, nl_b, nl_c, nl_d, &
    5132             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    5133             :                                      primitives, &
    5134     1496803 :                                      buffer1, buffer2)
    5135             : #else
    5136             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    5137             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    5138             :                                         sphi_a, &
    5139             :                                         sphi_b, &
    5140             :                                         sphi_c, &
    5141             :                                         sphi_d, &
    5142             :                                         primitives, &
    5143             :                                         buffer1, buffer2)
    5144             : #endif
    5145             :                CASE (2)
    5146             : #if __MAX_CONTR > 2 || __MAX_CONTR == 2
    5147             :                   CALL contract_dssd(work, &
    5148             :                                      nl_a, nl_b, nl_c, nl_d, &
    5149             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    5150             :                                      primitives, &
    5151      479223 :                                      buffer1, buffer2)
    5152             : #else
    5153             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    5154             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    5155             :                                         sphi_a, &
    5156             :                                         sphi_b, &
    5157             :                                         sphi_c, &
    5158             :                                         sphi_d, &
    5159             :                                         primitives, &
    5160             :                                         buffer1, buffer2)
    5161             : #endif
    5162             :                CASE (3)
    5163             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    5164             :                   CALL contract_dssf(work, &
    5165             :                                      nl_a, nl_b, nl_c, nl_d, &
    5166             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    5167             :                                      primitives, &
    5168             :                                      buffer1, buffer2)
    5169             : #else
    5170             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    5171             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    5172             :                                         sphi_a, &
    5173             :                                         sphi_b, &
    5174             :                                         sphi_c, &
    5175             :                                         sphi_d, &
    5176             :                                         primitives, &
    5177        2887 :                                         buffer1, buffer2)
    5178             : #endif
    5179             :                CASE (4)
    5180             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    5181             :                   CALL contract_dssg(work, &
    5182             :                                      nl_a, nl_b, nl_c, nl_d, &
    5183             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    5184             :                                      primitives, &
    5185             :                                      buffer1, buffer2)
    5186             : #else
    5187             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    5188             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    5189             :                                         sphi_a, &
    5190             :                                         sphi_b, &
    5191             :                                         sphi_c, &
    5192             :                                         sphi_d, &
    5193             :                                         primitives, &
    5194           0 :                                         buffer1, buffer2)
    5195             : #endif
    5196             :                CASE DEFAULT
    5197             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    5198             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    5199             :                                         sphi_a, &
    5200             :                                         sphi_b, &
    5201             :                                         sphi_c, &
    5202             :                                         sphi_d, &
    5203             :                                         primitives, &
    5204     4794518 :                                         buffer1, buffer2)
    5205             :                END SELECT
    5206             :             CASE (1)
    5207     6357305 :                SELECT CASE (n_d)
    5208             :                CASE (0)
    5209             : #if __MAX_CONTR > 2 || __MAX_CONTR == 2
    5210             :                   CALL contract_dsps(work, &
    5211             :                                      nl_a, nl_b, nl_c, nl_d, &
    5212             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    5213             :                                      primitives, &
    5214     1902420 :                                      buffer1, buffer2)
    5215             : #else
    5216             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    5217             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    5218             :                                         sphi_a, &
    5219             :                                         sphi_b, &
    5220             :                                         sphi_c, &
    5221             :                                         sphi_d, &
    5222             :                                         primitives, &
    5223             :                                         buffer1, buffer2)
    5224             : #endif
    5225             :                CASE (1)
    5226             : #if __MAX_CONTR > 2 || __MAX_CONTR == 2
    5227             :                   CALL contract_dspp(work, &
    5228             :                                      nl_a, nl_b, nl_c, nl_d, &
    5229             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    5230             :                                      primitives, &
    5231     1063471 :                                      buffer1, buffer2)
    5232             : #else
    5233             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    5234             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    5235             :                                         sphi_a, &
    5236             :                                         sphi_b, &
    5237             :                                         sphi_c, &
    5238             :                                         sphi_d, &
    5239             :                                         primitives, &
    5240             :                                         buffer1, buffer2)
    5241             : #endif
    5242             :                CASE (2)
    5243             : #if __MAX_CONTR > 2 || __MAX_CONTR == 2
    5244             :                   CALL contract_dspd(work, &
    5245             :                                      nl_a, nl_b, nl_c, nl_d, &
    5246             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    5247             :                                      primitives, &
    5248      380699 :                                      buffer1, buffer2)
    5249             : #else
    5250             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    5251             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    5252             :                                         sphi_a, &
    5253             :                                         sphi_b, &
    5254             :                                         sphi_c, &
    5255             :                                         sphi_d, &
    5256             :                                         primitives, &
    5257             :                                         buffer1, buffer2)
    5258             : #endif
    5259             :                CASE (3)
    5260             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    5261             :                   CALL contract_dspf(work, &
    5262             :                                      nl_a, nl_b, nl_c, nl_d, &
    5263             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    5264             :                                      primitives, &
    5265             :                                      buffer1, buffer2)
    5266             : #else
    5267             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    5268             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    5269             :                                         sphi_a, &
    5270             :                                         sphi_b, &
    5271             :                                         sphi_c, &
    5272             :                                         sphi_d, &
    5273             :                                         primitives, &
    5274        4412 :                                         buffer1, buffer2)
    5275             : #endif
    5276             :                CASE (4)
    5277             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    5278             :                   CALL contract_dspg(work, &
    5279             :                                      nl_a, nl_b, nl_c, nl_d, &
    5280             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    5281             :                                      primitives, &
    5282             :                                      buffer1, buffer2)
    5283             : #else
    5284             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    5285             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    5286             :                                         sphi_a, &
    5287             :                                         sphi_b, &
    5288             :                                         sphi_c, &
    5289             :                                         sphi_d, &
    5290             :                                         primitives, &
    5291           0 :                                         buffer1, buffer2)
    5292             : #endif
    5293             :                CASE DEFAULT
    5294             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    5295             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    5296             :                                         sphi_a, &
    5297             :                                         sphi_b, &
    5298             :                                         sphi_c, &
    5299             :                                         sphi_d, &
    5300             :                                         primitives, &
    5301     3351002 :                                         buffer1, buffer2)
    5302             :                END SELECT
    5303             :             CASE (2)
    5304     1675892 :                SELECT CASE (n_d)
    5305             :                CASE (0)
    5306             : #if __MAX_CONTR > 2 || __MAX_CONTR == 2
    5307             :                   CALL contract_dsds(work, &
    5308             :                                      nl_a, nl_b, nl_c, nl_d, &
    5309             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    5310             :                                      primitives, &
    5311      561854 :                                      buffer1, buffer2)
    5312             : #else
    5313             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    5314             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    5315             :                                         sphi_a, &
    5316             :                                         sphi_b, &
    5317             :                                         sphi_c, &
    5318             :                                         sphi_d, &
    5319             :                                         primitives, &
    5320             :                                         buffer1, buffer2)
    5321             : #endif
    5322             :                CASE (1)
    5323             : #if __MAX_CONTR > 2 || __MAX_CONTR == 2
    5324             :                   CALL contract_dsdp(work, &
    5325             :                                      nl_a, nl_b, nl_c, nl_d, &
    5326             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    5327             :                                      primitives, &
    5328      363551 :                                      buffer1, buffer2)
    5329             : #else
    5330             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    5331             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    5332             :                                         sphi_a, &
    5333             :                                         sphi_b, &
    5334             :                                         sphi_c, &
    5335             :                                         sphi_d, &
    5336             :                                         primitives, &
    5337             :                                         buffer1, buffer2)
    5338             : #endif
    5339             :                CASE (2)
    5340             : #if __MAX_CONTR > 2 || __MAX_CONTR == 2
    5341             :                   CALL contract_dsdd(work, &
    5342             :                                      nl_a, nl_b, nl_c, nl_d, &
    5343             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    5344             :                                      primitives, &
    5345      177323 :                                      buffer1, buffer2)
    5346             : #else
    5347             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    5348             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    5349             :                                         sphi_a, &
    5350             :                                         sphi_b, &
    5351             :                                         sphi_c, &
    5352             :                                         sphi_d, &
    5353             :                                         primitives, &
    5354             :                                         buffer1, buffer2)
    5355             : #endif
    5356             :                CASE (3)
    5357             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    5358             :                   CALL contract_dsdf(work, &
    5359             :                                      nl_a, nl_b, nl_c, nl_d, &
    5360             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    5361             :                                      primitives, &
    5362             :                                      buffer1, buffer2)
    5363             : #else
    5364             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    5365             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    5366             :                                         sphi_a, &
    5367             :                                         sphi_b, &
    5368             :                                         sphi_c, &
    5369             :                                         sphi_d, &
    5370             :                                         primitives, &
    5371        1155 :                                         buffer1, buffer2)
    5372             : #endif
    5373             :                CASE (4)
    5374             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    5375             :                   CALL contract_dsdg(work, &
    5376             :                                      nl_a, nl_b, nl_c, nl_d, &
    5377             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    5378             :                                      primitives, &
    5379             :                                      buffer1, buffer2)
    5380             : #else
    5381             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    5382             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    5383             :                                         sphi_a, &
    5384             :                                         sphi_b, &
    5385             :                                         sphi_c, &
    5386             :                                         sphi_d, &
    5387             :                                         primitives, &
    5388           0 :                                         buffer1, buffer2)
    5389             : #endif
    5390             :                CASE DEFAULT
    5391             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    5392             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    5393             :                                         sphi_a, &
    5394             :                                         sphi_b, &
    5395             :                                         sphi_c, &
    5396             :                                         sphi_d, &
    5397             :                                         primitives, &
    5398     1103883 :                                         buffer1, buffer2)
    5399             :                END SELECT
    5400             :             CASE (3)
    5401       14186 :                SELECT CASE (n_d)
    5402             :                CASE (0)
    5403             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    5404             :                   CALL contract_dsfs(work, &
    5405             :                                      nl_a, nl_b, nl_c, nl_d, &
    5406             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    5407             :                                      primitives, &
    5408             :                                      buffer1, buffer2)
    5409             : #else
    5410             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    5411             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    5412             :                                         sphi_a, &
    5413             :                                         sphi_b, &
    5414             :                                         sphi_c, &
    5415             :                                         sphi_d, &
    5416             :                                         primitives, &
    5417        4031 :                                         buffer1, buffer2)
    5418             : #endif
    5419             :                CASE (1)
    5420             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    5421             :                   CALL contract_dsfp(work, &
    5422             :                                      nl_a, nl_b, nl_c, nl_d, &
    5423             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    5424             :                                      primitives, &
    5425             :                                      buffer1, buffer2)
    5426             : #else
    5427             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    5428             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    5429             :                                         sphi_a, &
    5430             :                                         sphi_b, &
    5431             :                                         sphi_c, &
    5432             :                                         sphi_d, &
    5433             :                                         primitives, &
    5434        4119 :                                         buffer1, buffer2)
    5435             : #endif
    5436             :                CASE (2)
    5437             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    5438             :                   CALL contract_dsfd(work, &
    5439             :                                      nl_a, nl_b, nl_c, nl_d, &
    5440             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    5441             :                                      primitives, &
    5442             :                                      buffer1, buffer2)
    5443             : #else
    5444             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    5445             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    5446             :                                         sphi_a, &
    5447             :                                         sphi_b, &
    5448             :                                         sphi_c, &
    5449             :                                         sphi_d, &
    5450             :                                         primitives, &
    5451         967 :                                         buffer1, buffer2)
    5452             : #endif
    5453             :                CASE (3)
    5454             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    5455             :                   CALL contract_dsff(work, &
    5456             :                                      nl_a, nl_b, nl_c, nl_d, &
    5457             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    5458             :                                      primitives, &
    5459             :                                      buffer1, buffer2)
    5460             : #else
    5461             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    5462             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    5463             :                                         sphi_a, &
    5464             :                                         sphi_b, &
    5465             :                                         sphi_c, &
    5466             :                                         sphi_d, &
    5467             :                                         primitives, &
    5468        1038 :                                         buffer1, buffer2)
    5469             : #endif
    5470             :                CASE (4)
    5471             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    5472             :                   CALL contract_dsfg(work, &
    5473             :                                      nl_a, nl_b, nl_c, nl_d, &
    5474             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    5475             :                                      primitives, &
    5476             :                                      buffer1, buffer2)
    5477             : #else
    5478             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    5479             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    5480             :                                         sphi_a, &
    5481             :                                         sphi_b, &
    5482             :                                         sphi_c, &
    5483             :                                         sphi_d, &
    5484             :                                         primitives, &
    5485           0 :                                         buffer1, buffer2)
    5486             : #endif
    5487             :                CASE DEFAULT
    5488             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    5489             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    5490             :                                         sphi_a, &
    5491             :                                         sphi_b, &
    5492             :                                         sphi_c, &
    5493             :                                         sphi_d, &
    5494             :                                         primitives, &
    5495       10155 :                                         buffer1, buffer2)
    5496             :                END SELECT
    5497             :             CASE (4)
    5498           0 :                SELECT CASE (n_d)
    5499             :                CASE (0)
    5500             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    5501             :                   CALL contract_dsgs(work, &
    5502             :                                      nl_a, nl_b, nl_c, nl_d, &
    5503             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    5504             :                                      primitives, &
    5505             :                                      buffer1, buffer2)
    5506             : #else
    5507             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    5508             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    5509             :                                         sphi_a, &
    5510             :                                         sphi_b, &
    5511             :                                         sphi_c, &
    5512             :                                         sphi_d, &
    5513             :                                         primitives, &
    5514           0 :                                         buffer1, buffer2)
    5515             : #endif
    5516             :                CASE (1)
    5517             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    5518             :                   CALL contract_dsgp(work, &
    5519             :                                      nl_a, nl_b, nl_c, nl_d, &
    5520             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    5521             :                                      primitives, &
    5522             :                                      buffer1, buffer2)
    5523             : #else
    5524             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    5525             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    5526             :                                         sphi_a, &
    5527             :                                         sphi_b, &
    5528             :                                         sphi_c, &
    5529             :                                         sphi_d, &
    5530             :                                         primitives, &
    5531           0 :                                         buffer1, buffer2)
    5532             : #endif
    5533             :                CASE (2)
    5534             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    5535             :                   CALL contract_dsgd(work, &
    5536             :                                      nl_a, nl_b, nl_c, nl_d, &
    5537             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    5538             :                                      primitives, &
    5539             :                                      buffer1, buffer2)
    5540             : #else
    5541             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    5542             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    5543             :                                         sphi_a, &
    5544             :                                         sphi_b, &
    5545             :                                         sphi_c, &
    5546             :                                         sphi_d, &
    5547             :                                         primitives, &
    5548           0 :                                         buffer1, buffer2)
    5549             : #endif
    5550             :                CASE (3)
    5551             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    5552             :                   CALL contract_dsgf(work, &
    5553             :                                      nl_a, nl_b, nl_c, nl_d, &
    5554             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    5555             :                                      primitives, &
    5556             :                                      buffer1, buffer2)
    5557             : #else
    5558             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    5559             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    5560             :                                         sphi_a, &
    5561             :                                         sphi_b, &
    5562             :                                         sphi_c, &
    5563             :                                         sphi_d, &
    5564             :                                         primitives, &
    5565           0 :                                         buffer1, buffer2)
    5566             : #endif
    5567             :                CASE (4)
    5568             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    5569             :                   CALL contract_dsgg(work, &
    5570             :                                      nl_a, nl_b, nl_c, nl_d, &
    5571             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    5572             :                                      primitives, &
    5573             :                                      buffer1, buffer2)
    5574             : #else
    5575             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    5576             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    5577             :                                         sphi_a, &
    5578             :                                         sphi_b, &
    5579             :                                         sphi_c, &
    5580             :                                         sphi_d, &
    5581             :                                         primitives, &
    5582           0 :                                         buffer1, buffer2)
    5583             : #endif
    5584             :                CASE DEFAULT
    5585             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    5586             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    5587             :                                         sphi_a, &
    5588             :                                         sphi_b, &
    5589             :                                         sphi_c, &
    5590             :                                         sphi_d, &
    5591             :                                         primitives, &
    5592           0 :                                         buffer1, buffer2)
    5593             :                END SELECT
    5594             :             CASE DEFAULT
    5595             :                CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    5596             :                                      work, nl_a, nl_b, nl_c, nl_d, &
    5597             :                                      sphi_a, &
    5598             :                                      sphi_b, &
    5599             :                                      sphi_c, &
    5600             :                                      sphi_d, &
    5601             :                                      primitives, &
    5602     9259558 :                                      buffer1, buffer2)
    5603             :             END SELECT
    5604             :          CASE (1)
    5605     7301929 :             SELECT CASE (n_c)
    5606             :             CASE (0)
    5607     4207890 :                SELECT CASE (n_d)
    5608             :                CASE (0)
    5609             : #if __MAX_CONTR > 2 || __MAX_CONTR == 2
    5610             :                   CALL contract_dpss(work, &
    5611             :                                      nl_a, nl_b, nl_c, nl_d, &
    5612             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    5613             :                                      primitives, &
    5614     1092281 :                                      buffer1, buffer2)
    5615             : #else
    5616             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    5617             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    5618             :                                         sphi_a, &
    5619             :                                         sphi_b, &
    5620             :                                         sphi_c, &
    5621             :                                         sphi_d, &
    5622             :                                         primitives, &
    5623             :                                         buffer1, buffer2)
    5624             : #endif
    5625             :                CASE (1)
    5626             : #if __MAX_CONTR > 2 || __MAX_CONTR == 2
    5627             :                   CALL contract_dpsp(work, &
    5628             :                                      nl_a, nl_b, nl_c, nl_d, &
    5629             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    5630             :                                      primitives, &
    5631      533029 :                                      buffer1, buffer2)
    5632             : #else
    5633             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    5634             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    5635             :                                         sphi_a, &
    5636             :                                         sphi_b, &
    5637             :                                         sphi_c, &
    5638             :                                         sphi_d, &
    5639             :                                         primitives, &
    5640             :                                         buffer1, buffer2)
    5641             : #endif
    5642             :                CASE (2)
    5643             : #if __MAX_CONTR > 2 || __MAX_CONTR == 2
    5644             :                   CALL contract_dpsd(work, &
    5645             :                                      nl_a, nl_b, nl_c, nl_d, &
    5646             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    5647             :                                      primitives, &
    5648      271849 :                                      buffer1, buffer2)
    5649             : #else
    5650             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    5651             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    5652             :                                         sphi_a, &
    5653             :                                         sphi_b, &
    5654             :                                         sphi_c, &
    5655             :                                         sphi_d, &
    5656             :                                         primitives, &
    5657             :                                         buffer1, buffer2)
    5658             : #endif
    5659             :                CASE (3)
    5660             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    5661             :                   CALL contract_dpsf(work, &
    5662             :                                      nl_a, nl_b, nl_c, nl_d, &
    5663             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    5664             :                                      primitives, &
    5665             :                                      buffer1, buffer2)
    5666             : #else
    5667             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    5668             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    5669             :                                         sphi_a, &
    5670             :                                         sphi_b, &
    5671             :                                         sphi_c, &
    5672             :                                         sphi_d, &
    5673             :                                         primitives, &
    5674        3278 :                                         buffer1, buffer2)
    5675             : #endif
    5676             :                CASE (4)
    5677             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    5678             :                   CALL contract_dpsg(work, &
    5679             :                                      nl_a, nl_b, nl_c, nl_d, &
    5680             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    5681             :                                      primitives, &
    5682             :                                      buffer1, buffer2)
    5683             : #else
    5684             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    5685             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    5686             :                                         sphi_a, &
    5687             :                                         sphi_b, &
    5688             :                                         sphi_c, &
    5689             :                                         sphi_d, &
    5690             :                                         primitives, &
    5691           0 :                                         buffer1, buffer2)
    5692             : #endif
    5693             :                CASE DEFAULT
    5694             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    5695             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    5696             :                                         sphi_a, &
    5697             :                                         sphi_b, &
    5698             :                                         sphi_c, &
    5699             :                                         sphi_d, &
    5700             :                                         primitives, &
    5701     1900437 :                                         buffer1, buffer2)
    5702             :                END SELECT
    5703             :             CASE (1)
    5704     2239042 :                SELECT CASE (n_d)
    5705             :                CASE (0)
    5706             : #if __MAX_CONTR > 2 || __MAX_CONTR == 2
    5707             :                   CALL contract_dpps(work, &
    5708             :                                      nl_a, nl_b, nl_c, nl_d, &
    5709             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    5710             :                                      primitives, &
    5711      527126 :                                      buffer1, buffer2)
    5712             : #else
    5713             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    5714             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    5715             :                                         sphi_a, &
    5716             :                                         sphi_b, &
    5717             :                                         sphi_c, &
    5718             :                                         sphi_d, &
    5719             :                                         primitives, &
    5720             :                                         buffer1, buffer2)
    5721             : #endif
    5722             :                CASE (1)
    5723             : #if __MAX_CONTR > 2 || __MAX_CONTR == 2
    5724             :                   CALL contract_dppp(work, &
    5725             :                                      nl_a, nl_b, nl_c, nl_d, &
    5726             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    5727             :                                      primitives, &
    5728      501461 :                                      buffer1, buffer2)
    5729             : #else
    5730             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    5731             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    5732             :                                         sphi_a, &
    5733             :                                         sphi_b, &
    5734             :                                         sphi_c, &
    5735             :                                         sphi_d, &
    5736             :                                         primitives, &
    5737             :                                         buffer1, buffer2)
    5738             : #endif
    5739             :                CASE (2)
    5740             : #if __MAX_CONTR > 2 || __MAX_CONTR == 2
    5741             :                   CALL contract_dppd(work, &
    5742             :                                      nl_a, nl_b, nl_c, nl_d, &
    5743             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    5744             :                                      primitives, &
    5745      185190 :                                      buffer1, buffer2)
    5746             : #else
    5747             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    5748             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    5749             :                                         sphi_a, &
    5750             :                                         sphi_b, &
    5751             :                                         sphi_c, &
    5752             :                                         sphi_d, &
    5753             :                                         primitives, &
    5754             :                                         buffer1, buffer2)
    5755             : #endif
    5756             :                CASE (3)
    5757             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    5758             :                   CALL contract_dppf(work, &
    5759             :                                      nl_a, nl_b, nl_c, nl_d, &
    5760             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    5761             :                                      primitives, &
    5762             :                                      buffer1, buffer2)
    5763             : #else
    5764             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    5765             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    5766             :                                         sphi_a, &
    5767             :                                         sphi_b, &
    5768             :                                         sphi_c, &
    5769             :                                         sphi_d, &
    5770             :                                         primitives, &
    5771        1395 :                                         buffer1, buffer2)
    5772             : #endif
    5773             :                CASE (4)
    5774             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    5775             :                   CALL contract_dppg(work, &
    5776             :                                      nl_a, nl_b, nl_c, nl_d, &
    5777             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    5778             :                                      primitives, &
    5779             :                                      buffer1, buffer2)
    5780             : #else
    5781             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    5782             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    5783             :                                         sphi_a, &
    5784             :                                         sphi_b, &
    5785             :                                         sphi_c, &
    5786             :                                         sphi_d, &
    5787             :                                         primitives, &
    5788           0 :                                         buffer1, buffer2)
    5789             : #endif
    5790             :                CASE DEFAULT
    5791             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    5792             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    5793             :                                         sphi_a, &
    5794             :                                         sphi_b, &
    5795             :                                         sphi_c, &
    5796             :                                         sphi_d, &
    5797             :                                         primitives, &
    5798     1215172 :                                         buffer1, buffer2)
    5799             :                END SELECT
    5800             :             CASE (2)
    5801      736663 :                SELECT CASE (n_d)
    5802             :                CASE (0)
    5803             : #if __MAX_CONTR > 2 || __MAX_CONTR == 2
    5804             :                   CALL contract_dpds(work, &
    5805             :                                      nl_a, nl_b, nl_c, nl_d, &
    5806             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    5807             :                                      primitives, &
    5808      234662 :                                      buffer1, buffer2)
    5809             : #else
    5810             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    5811             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    5812             :                                         sphi_a, &
    5813             :                                         sphi_b, &
    5814             :                                         sphi_c, &
    5815             :                                         sphi_d, &
    5816             :                                         primitives, &
    5817             :                                         buffer1, buffer2)
    5818             : #endif
    5819             :                CASE (1)
    5820             : #if __MAX_CONTR > 2 || __MAX_CONTR == 2
    5821             :                   CALL contract_dpdp(work, &
    5822             :                                      nl_a, nl_b, nl_c, nl_d, &
    5823             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    5824             :                                      primitives, &
    5825      154599 :                                      buffer1, buffer2)
    5826             : #else
    5827             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    5828             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    5829             :                                         sphi_a, &
    5830             :                                         sphi_b, &
    5831             :                                         sphi_c, &
    5832             :                                         sphi_d, &
    5833             :                                         primitives, &
    5834             :                                         buffer1, buffer2)
    5835             : #endif
    5836             :                CASE (2)
    5837             : #if __MAX_CONTR > 2 || __MAX_CONTR == 2
    5838             :                   CALL contract_dpdd(work, &
    5839             :                                      nl_a, nl_b, nl_c, nl_d, &
    5840             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    5841             :                                      primitives, &
    5842      106268 :                                      buffer1, buffer2)
    5843             : #else
    5844             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    5845             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    5846             :                                         sphi_a, &
    5847             :                                         sphi_b, &
    5848             :                                         sphi_c, &
    5849             :                                         sphi_d, &
    5850             :                                         primitives, &
    5851             :                                         buffer1, buffer2)
    5852             : #endif
    5853             :                CASE (3)
    5854             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    5855             :                   CALL contract_dpdf(work, &
    5856             :                                      nl_a, nl_b, nl_c, nl_d, &
    5857             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    5858             :                                      primitives, &
    5859             :                                      buffer1, buffer2)
    5860             : #else
    5861             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    5862             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    5863             :                                         sphi_a, &
    5864             :                                         sphi_b, &
    5865             :                                         sphi_c, &
    5866             :                                         sphi_d, &
    5867             :                                         primitives, &
    5868        1215 :                                         buffer1, buffer2)
    5869             : #endif
    5870             :                CASE (4)
    5871             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    5872             :                   CALL contract_dpdg(work, &
    5873             :                                      nl_a, nl_b, nl_c, nl_d, &
    5874             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    5875             :                                      primitives, &
    5876             :                                      buffer1, buffer2)
    5877             : #else
    5878             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    5879             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    5880             :                                         sphi_a, &
    5881             :                                         sphi_b, &
    5882             :                                         sphi_c, &
    5883             :                                         sphi_d, &
    5884             :                                         primitives, &
    5885           0 :                                         buffer1, buffer2)
    5886             : #endif
    5887             :                CASE DEFAULT
    5888             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    5889             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    5890             :                                         sphi_a, &
    5891             :                                         sphi_b, &
    5892             :                                         sphi_c, &
    5893             :                                         sphi_d, &
    5894             :                                         primitives, &
    5895      496744 :                                         buffer1, buffer2)
    5896             :                END SELECT
    5897             :             CASE (3)
    5898        8141 :                SELECT CASE (n_d)
    5899             :                CASE (0)
    5900             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    5901             :                   CALL contract_dpfs(work, &
    5902             :                                      nl_a, nl_b, nl_c, nl_d, &
    5903             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    5904             :                                      primitives, &
    5905             :                                      buffer1, buffer2)
    5906             : #else
    5907             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    5908             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    5909             :                                         sphi_a, &
    5910             :                                         sphi_b, &
    5911             :                                         sphi_c, &
    5912             :                                         sphi_d, &
    5913             :                                         primitives, &
    5914        2884 :                                         buffer1, buffer2)
    5915             : #endif
    5916             :                CASE (1)
    5917             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    5918             :                   CALL contract_dpfp(work, &
    5919             :                                      nl_a, nl_b, nl_c, nl_d, &
    5920             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    5921             :                                      primitives, &
    5922             :                                      buffer1, buffer2)
    5923             : #else
    5924             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    5925             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    5926             :                                         sphi_a, &
    5927             :                                         sphi_b, &
    5928             :                                         sphi_c, &
    5929             :                                         sphi_d, &
    5930             :                                         primitives, &
    5931        1025 :                                         buffer1, buffer2)
    5932             : #endif
    5933             :                CASE (2)
    5934             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    5935             :                   CALL contract_dpfd(work, &
    5936             :                                      nl_a, nl_b, nl_c, nl_d, &
    5937             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    5938             :                                      primitives, &
    5939             :                                      buffer1, buffer2)
    5940             : #else
    5941             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    5942             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    5943             :                                         sphi_a, &
    5944             :                                         sphi_b, &
    5945             :                                         sphi_c, &
    5946             :                                         sphi_d, &
    5947             :                                         primitives, &
    5948         953 :                                         buffer1, buffer2)
    5949             : #endif
    5950             :                CASE (3)
    5951             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    5952             :                   CALL contract_dpff(work, &
    5953             :                                      nl_a, nl_b, nl_c, nl_d, &
    5954             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    5955             :                                      primitives, &
    5956             :                                      buffer1, buffer2)
    5957             : #else
    5958             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    5959             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    5960             :                                         sphi_a, &
    5961             :                                         sphi_b, &
    5962             :                                         sphi_c, &
    5963             :                                         sphi_d, &
    5964             :                                         primitives, &
    5965         395 :                                         buffer1, buffer2)
    5966             : #endif
    5967             :                CASE (4)
    5968             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    5969             :                   CALL contract_dpfg(work, &
    5970             :                                      nl_a, nl_b, nl_c, nl_d, &
    5971             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    5972             :                                      primitives, &
    5973             :                                      buffer1, buffer2)
    5974             : #else
    5975             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    5976             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    5977             :                                         sphi_a, &
    5978             :                                         sphi_b, &
    5979             :                                         sphi_c, &
    5980             :                                         sphi_d, &
    5981             :                                         primitives, &
    5982           0 :                                         buffer1, buffer2)
    5983             : #endif
    5984             :                CASE DEFAULT
    5985             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    5986             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    5987             :                                         sphi_a, &
    5988             :                                         sphi_b, &
    5989             :                                         sphi_c, &
    5990             :                                         sphi_d, &
    5991             :                                         primitives, &
    5992        5257 :                                         buffer1, buffer2)
    5993             :                END SELECT
    5994             :             CASE (4)
    5995           0 :                SELECT CASE (n_d)
    5996             :                CASE (0)
    5997             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    5998             :                   CALL contract_dpgs(work, &
    5999             :                                      nl_a, nl_b, nl_c, nl_d, &
    6000             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    6001             :                                      primitives, &
    6002             :                                      buffer1, buffer2)
    6003             : #else
    6004             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    6005             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    6006             :                                         sphi_a, &
    6007             :                                         sphi_b, &
    6008             :                                         sphi_c, &
    6009             :                                         sphi_d, &
    6010             :                                         primitives, &
    6011           0 :                                         buffer1, buffer2)
    6012             : #endif
    6013             :                CASE (1)
    6014             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    6015             :                   CALL contract_dpgp(work, &
    6016             :                                      nl_a, nl_b, nl_c, nl_d, &
    6017             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    6018             :                                      primitives, &
    6019             :                                      buffer1, buffer2)
    6020             : #else
    6021             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    6022             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    6023             :                                         sphi_a, &
    6024             :                                         sphi_b, &
    6025             :                                         sphi_c, &
    6026             :                                         sphi_d, &
    6027             :                                         primitives, &
    6028           0 :                                         buffer1, buffer2)
    6029             : #endif
    6030             :                CASE (2)
    6031             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    6032             :                   CALL contract_dpgd(work, &
    6033             :                                      nl_a, nl_b, nl_c, nl_d, &
    6034             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    6035             :                                      primitives, &
    6036             :                                      buffer1, buffer2)
    6037             : #else
    6038             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    6039             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    6040             :                                         sphi_a, &
    6041             :                                         sphi_b, &
    6042             :                                         sphi_c, &
    6043             :                                         sphi_d, &
    6044             :                                         primitives, &
    6045           0 :                                         buffer1, buffer2)
    6046             : #endif
    6047             :                CASE (3)
    6048             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    6049             :                   CALL contract_dpgf(work, &
    6050             :                                      nl_a, nl_b, nl_c, nl_d, &
    6051             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    6052             :                                      primitives, &
    6053             :                                      buffer1, buffer2)
    6054             : #else
    6055             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    6056             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    6057             :                                         sphi_a, &
    6058             :                                         sphi_b, &
    6059             :                                         sphi_c, &
    6060             :                                         sphi_d, &
    6061             :                                         primitives, &
    6062           0 :                                         buffer1, buffer2)
    6063             : #endif
    6064             :                CASE (4)
    6065             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    6066             :                   CALL contract_dpgg(work, &
    6067             :                                      nl_a, nl_b, nl_c, nl_d, &
    6068             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    6069             :                                      primitives, &
    6070             :                                      buffer1, buffer2)
    6071             : #else
    6072             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    6073             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    6074             :                                         sphi_a, &
    6075             :                                         sphi_b, &
    6076             :                                         sphi_c, &
    6077             :                                         sphi_d, &
    6078             :                                         primitives, &
    6079           0 :                                         buffer1, buffer2)
    6080             : #endif
    6081             :                CASE DEFAULT
    6082             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    6083             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    6084             :                                         sphi_a, &
    6085             :                                         sphi_b, &
    6086             :                                         sphi_c, &
    6087             :                                         sphi_d, &
    6088             :                                         primitives, &
    6089           0 :                                         buffer1, buffer2)
    6090             :                END SELECT
    6091             :             CASE DEFAULT
    6092             :                CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    6093             :                                      work, nl_a, nl_b, nl_c, nl_d, &
    6094             :                                      sphi_a, &
    6095             :                                      sphi_b, &
    6096             :                                      sphi_c, &
    6097             :                                      sphi_d, &
    6098             :                                      primitives, &
    6099     3617610 :                                      buffer1, buffer2)
    6100             :             END SELECT
    6101             :          CASE (2)
    6102     2689023 :             SELECT CASE (n_c)
    6103             :             CASE (0)
    6104     1881084 :                SELECT CASE (n_d)
    6105             :                CASE (0)
    6106             : #if __MAX_CONTR > 2 || __MAX_CONTR == 2
    6107             :                   CALL contract_ddss(work, &
    6108             :                                      nl_a, nl_b, nl_c, nl_d, &
    6109             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    6110             :                                      primitives, &
    6111      385564 :                                      buffer1, buffer2)
    6112             : #else
    6113             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    6114             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    6115             :                                         sphi_a, &
    6116             :                                         sphi_b, &
    6117             :                                         sphi_c, &
    6118             :                                         sphi_d, &
    6119             :                                         primitives, &
    6120             :                                         buffer1, buffer2)
    6121             : #endif
    6122             :                CASE (1)
    6123             : #if __MAX_CONTR > 2 || __MAX_CONTR == 2
    6124             :                   CALL contract_ddsp(work, &
    6125             :                                      nl_a, nl_b, nl_c, nl_d, &
    6126             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    6127             :                                      primitives, &
    6128      311394 :                                      buffer1, buffer2)
    6129             : #else
    6130             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    6131             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    6132             :                                         sphi_a, &
    6133             :                                         sphi_b, &
    6134             :                                         sphi_c, &
    6135             :                                         sphi_d, &
    6136             :                                         primitives, &
    6137             :                                         buffer1, buffer2)
    6138             : #endif
    6139             :                CASE (2)
    6140             : #if __MAX_CONTR > 2 || __MAX_CONTR == 2
    6141             :                   CALL contract_ddsd(work, &
    6142             :                                      nl_a, nl_b, nl_c, nl_d, &
    6143             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    6144             :                                      primitives, &
    6145      180417 :                                      buffer1, buffer2)
    6146             : #else
    6147             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    6148             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    6149             :                                         sphi_a, &
    6150             :                                         sphi_b, &
    6151             :                                         sphi_c, &
    6152             :                                         sphi_d, &
    6153             :                                         primitives, &
    6154             :                                         buffer1, buffer2)
    6155             : #endif
    6156             :                CASE (3)
    6157             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    6158             :                   CALL contract_ddsf(work, &
    6159             :                                      nl_a, nl_b, nl_c, nl_d, &
    6160             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    6161             :                                      primitives, &
    6162             :                                      buffer1, buffer2)
    6163             : #else
    6164             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    6165             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    6166             :                                         sphi_a, &
    6167             :                                         sphi_b, &
    6168             :                                         sphi_c, &
    6169             :                                         sphi_d, &
    6170             :                                         primitives, &
    6171        1149 :                                         buffer1, buffer2)
    6172             : #endif
    6173             :                CASE (4)
    6174             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    6175             :                   CALL contract_ddsg(work, &
    6176             :                                      nl_a, nl_b, nl_c, nl_d, &
    6177             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    6178             :                                      primitives, &
    6179             :                                      buffer1, buffer2)
    6180             : #else
    6181             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    6182             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    6183             :                                         sphi_a, &
    6184             :                                         sphi_b, &
    6185             :                                         sphi_c, &
    6186             :                                         sphi_d, &
    6187             :                                         primitives, &
    6188           0 :                                         buffer1, buffer2)
    6189             : #endif
    6190             :                CASE DEFAULT
    6191             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    6192             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    6193             :                                         sphi_a, &
    6194             :                                         sphi_b, &
    6195             :                                         sphi_c, &
    6196             :                                         sphi_d, &
    6197             :                                         primitives, &
    6198      878524 :                                         buffer1, buffer2)
    6199             :                END SELECT
    6200             :             CASE (1)
    6201     1174882 :                SELECT CASE (n_d)
    6202             :                CASE (0)
    6203             : #if __MAX_CONTR > 2 || __MAX_CONTR == 2
    6204             :                   CALL contract_ddps(work, &
    6205             :                                      nl_a, nl_b, nl_c, nl_d, &
    6206             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    6207             :                                      primitives, &
    6208      272023 :                                      buffer1, buffer2)
    6209             : #else
    6210             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    6211             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    6212             :                                         sphi_a, &
    6213             :                                         sphi_b, &
    6214             :                                         sphi_c, &
    6215             :                                         sphi_d, &
    6216             :                                         primitives, &
    6217             :                                         buffer1, buffer2)
    6218             : #endif
    6219             :                CASE (1)
    6220             : #if __MAX_CONTR > 2 || __MAX_CONTR == 2
    6221             :                   CALL contract_ddpp(work, &
    6222             :                                      nl_a, nl_b, nl_c, nl_d, &
    6223             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    6224             :                                      primitives, &
    6225      199928 :                                      buffer1, buffer2)
    6226             : #else
    6227             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    6228             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    6229             :                                         sphi_a, &
    6230             :                                         sphi_b, &
    6231             :                                         sphi_c, &
    6232             :                                         sphi_d, &
    6233             :                                         primitives, &
    6234             :                                         buffer1, buffer2)
    6235             : #endif
    6236             :                CASE (2)
    6237             : #if __MAX_CONTR > 2 || __MAX_CONTR == 2
    6238             :                   CALL contract_ddpd(work, &
    6239             :                                      nl_a, nl_b, nl_c, nl_d, &
    6240             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    6241             :                                      primitives, &
    6242      143211 :                                      buffer1, buffer2)
    6243             : #else
    6244             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    6245             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    6246             :                                         sphi_a, &
    6247             :                                         sphi_b, &
    6248             :                                         sphi_c, &
    6249             :                                         sphi_d, &
    6250             :                                         primitives, &
    6251             :                                         buffer1, buffer2)
    6252             : #endif
    6253             :                CASE (3)
    6254             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    6255             :                   CALL contract_ddpf(work, &
    6256             :                                      nl_a, nl_b, nl_c, nl_d, &
    6257             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    6258             :                                      primitives, &
    6259             :                                      buffer1, buffer2)
    6260             : #else
    6261             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    6262             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    6263             :                                         sphi_a, &
    6264             :                                         sphi_b, &
    6265             :                                         sphi_c, &
    6266             :                                         sphi_d, &
    6267             :                                         primitives, &
    6268        1834 :                                         buffer1, buffer2)
    6269             : #endif
    6270             :                CASE (4)
    6271             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    6272             :                   CALL contract_ddpg(work, &
    6273             :                                      nl_a, nl_b, nl_c, nl_d, &
    6274             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    6275             :                                      primitives, &
    6276             :                                      buffer1, buffer2)
    6277             : #else
    6278             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    6279             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    6280             :                                         sphi_a, &
    6281             :                                         sphi_b, &
    6282             :                                         sphi_c, &
    6283             :                                         sphi_d, &
    6284             :                                         primitives, &
    6285           0 :                                         buffer1, buffer2)
    6286             : #endif
    6287             :                CASE DEFAULT
    6288             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    6289             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    6290             :                                         sphi_a, &
    6291             :                                         sphi_b, &
    6292             :                                         sphi_c, &
    6293             :                                         sphi_d, &
    6294             :                                         primitives, &
    6295      616996 :                                         buffer1, buffer2)
    6296             :                END SELECT
    6297             :             CASE (2)
    6298      398856 :                SELECT CASE (n_d)
    6299             :                CASE (0)
    6300             : #if __MAX_CONTR > 2 || __MAX_CONTR == 2
    6301             :                   CALL contract_ddds(work, &
    6302             :                                      nl_a, nl_b, nl_c, nl_d, &
    6303             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    6304             :                                      primitives, &
    6305      110494 :                                      buffer1, buffer2)
    6306             : #else
    6307             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    6308             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    6309             :                                         sphi_a, &
    6310             :                                         sphi_b, &
    6311             :                                         sphi_c, &
    6312             :                                         sphi_d, &
    6313             :                                         primitives, &
    6314             :                                         buffer1, buffer2)
    6315             : #endif
    6316             :                CASE (1)
    6317             : #if __MAX_CONTR > 2 || __MAX_CONTR == 2
    6318             :                   CALL contract_dddp(work, &
    6319             :                                      nl_a, nl_b, nl_c, nl_d, &
    6320             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    6321             :                                      primitives, &
    6322       96581 :                                      buffer1, buffer2)
    6323             : #else
    6324             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    6325             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    6326             :                                         sphi_a, &
    6327             :                                         sphi_b, &
    6328             :                                         sphi_c, &
    6329             :                                         sphi_d, &
    6330             :                                         primitives, &
    6331             :                                         buffer1, buffer2)
    6332             : #endif
    6333             :                CASE (2)
    6334             : #if __MAX_CONTR > 2 || __MAX_CONTR == 2
    6335             :                   CALL contract_dddd(work, &
    6336             :                                      nl_a, nl_b, nl_c, nl_d, &
    6337             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    6338             :                                      primitives, &
    6339       78279 :                                      buffer1, buffer2)
    6340             : #else
    6341             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    6342             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    6343             :                                         sphi_a, &
    6344             :                                         sphi_b, &
    6345             :                                         sphi_c, &
    6346             :                                         sphi_d, &
    6347             :                                         primitives, &
    6348             :                                         buffer1, buffer2)
    6349             : #endif
    6350             :                CASE (3)
    6351             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    6352             :                   CALL contract_dddf(work, &
    6353             :                                      nl_a, nl_b, nl_c, nl_d, &
    6354             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    6355             :                                      primitives, &
    6356             :                                      buffer1, buffer2)
    6357             : #else
    6358             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    6359             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    6360             :                                         sphi_a, &
    6361             :                                         sphi_b, &
    6362             :                                         sphi_c, &
    6363             :                                         sphi_d, &
    6364             :                                         primitives, &
    6365         509 :                                         buffer1, buffer2)
    6366             : #endif
    6367             :                CASE (4)
    6368             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    6369             :                   CALL contract_dddg(work, &
    6370             :                                      nl_a, nl_b, nl_c, nl_d, &
    6371             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    6372             :                                      primitives, &
    6373             :                                      buffer1, buffer2)
    6374             : #else
    6375             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    6376             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    6377             :                                         sphi_a, &
    6378             :                                         sphi_b, &
    6379             :                                         sphi_c, &
    6380             :                                         sphi_d, &
    6381             :                                         primitives, &
    6382           0 :                                         buffer1, buffer2)
    6383             : #endif
    6384             :                CASE DEFAULT
    6385             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    6386             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    6387             :                                         sphi_a, &
    6388             :                                         sphi_b, &
    6389             :                                         sphi_c, &
    6390             :                                         sphi_d, &
    6391             :                                         primitives, &
    6392      285863 :                                         buffer1, buffer2)
    6393             :                END SELECT
    6394             :             CASE (3)
    6395        3106 :                SELECT CASE (n_d)
    6396             :                CASE (0)
    6397             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    6398             :                   CALL contract_ddfs(work, &
    6399             :                                      nl_a, nl_b, nl_c, nl_d, &
    6400             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    6401             :                                      primitives, &
    6402             :                                      buffer1, buffer2)
    6403             : #else
    6404             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    6405             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    6406             :                                         sphi_a, &
    6407             :                                         sphi_b, &
    6408             :                                         sphi_c, &
    6409             :                                         sphi_d, &
    6410             :                                         primitives, &
    6411         607 :                                         buffer1, buffer2)
    6412             : #endif
    6413             :                CASE (1)
    6414             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    6415             :                   CALL contract_ddfp(work, &
    6416             :                                      nl_a, nl_b, nl_c, nl_d, &
    6417             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    6418             :                                      primitives, &
    6419             :                                      buffer1, buffer2)
    6420             : #else
    6421             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    6422             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    6423             :                                         sphi_a, &
    6424             :                                         sphi_b, &
    6425             :                                         sphi_c, &
    6426             :                                         sphi_d, &
    6427             :                                         primitives, &
    6428        1032 :                                         buffer1, buffer2)
    6429             : #endif
    6430             :                CASE (2)
    6431             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    6432             :                   CALL contract_ddfd(work, &
    6433             :                                      nl_a, nl_b, nl_c, nl_d, &
    6434             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    6435             :                                      primitives, &
    6436             :                                      buffer1, buffer2)
    6437             : #else
    6438             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    6439             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    6440             :                                         sphi_a, &
    6441             :                                         sphi_b, &
    6442             :                                         sphi_c, &
    6443             :                                         sphi_d, &
    6444             :                                         primitives, &
    6445         328 :                                         buffer1, buffer2)
    6446             : #endif
    6447             :                CASE (3)
    6448             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    6449             :                   CALL contract_ddff(work, &
    6450             :                                      nl_a, nl_b, nl_c, nl_d, &
    6451             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    6452             :                                      primitives, &
    6453             :                                      buffer1, buffer2)
    6454             : #else
    6455             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    6456             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    6457             :                                         sphi_a, &
    6458             :                                         sphi_b, &
    6459             :                                         sphi_c, &
    6460             :                                         sphi_d, &
    6461             :                                         primitives, &
    6462         532 :                                         buffer1, buffer2)
    6463             : #endif
    6464             :                CASE (4)
    6465             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    6466             :                   CALL contract_ddfg(work, &
    6467             :                                      nl_a, nl_b, nl_c, nl_d, &
    6468             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    6469             :                                      primitives, &
    6470             :                                      buffer1, buffer2)
    6471             : #else
    6472             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    6473             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    6474             :                                         sphi_a, &
    6475             :                                         sphi_b, &
    6476             :                                         sphi_c, &
    6477             :                                         sphi_d, &
    6478             :                                         primitives, &
    6479           0 :                                         buffer1, buffer2)
    6480             : #endif
    6481             :                CASE DEFAULT
    6482             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    6483             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    6484             :                                         sphi_a, &
    6485             :                                         sphi_b, &
    6486             :                                         sphi_c, &
    6487             :                                         sphi_d, &
    6488             :                                         primitives, &
    6489        2499 :                                         buffer1, buffer2)
    6490             :                END SELECT
    6491             :             CASE (4)
    6492           0 :                SELECT CASE (n_d)
    6493             :                CASE (0)
    6494             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    6495             :                   CALL contract_ddgs(work, &
    6496             :                                      nl_a, nl_b, nl_c, nl_d, &
    6497             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    6498             :                                      primitives, &
    6499             :                                      buffer1, buffer2)
    6500             : #else
    6501             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    6502             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    6503             :                                         sphi_a, &
    6504             :                                         sphi_b, &
    6505             :                                         sphi_c, &
    6506             :                                         sphi_d, &
    6507             :                                         primitives, &
    6508           0 :                                         buffer1, buffer2)
    6509             : #endif
    6510             :                CASE (1)
    6511             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    6512             :                   CALL contract_ddgp(work, &
    6513             :                                      nl_a, nl_b, nl_c, nl_d, &
    6514             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    6515             :                                      primitives, &
    6516             :                                      buffer1, buffer2)
    6517             : #else
    6518             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    6519             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    6520             :                                         sphi_a, &
    6521             :                                         sphi_b, &
    6522             :                                         sphi_c, &
    6523             :                                         sphi_d, &
    6524             :                                         primitives, &
    6525           0 :                                         buffer1, buffer2)
    6526             : #endif
    6527             :                CASE (2)
    6528             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    6529             :                   CALL contract_ddgd(work, &
    6530             :                                      nl_a, nl_b, nl_c, nl_d, &
    6531             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    6532             :                                      primitives, &
    6533             :                                      buffer1, buffer2)
    6534             : #else
    6535             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    6536             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    6537             :                                         sphi_a, &
    6538             :                                         sphi_b, &
    6539             :                                         sphi_c, &
    6540             :                                         sphi_d, &
    6541             :                                         primitives, &
    6542           0 :                                         buffer1, buffer2)
    6543             : #endif
    6544             :                CASE (3)
    6545             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    6546             :                   CALL contract_ddgf(work, &
    6547             :                                      nl_a, nl_b, nl_c, nl_d, &
    6548             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    6549             :                                      primitives, &
    6550             :                                      buffer1, buffer2)
    6551             : #else
    6552             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    6553             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    6554             :                                         sphi_a, &
    6555             :                                         sphi_b, &
    6556             :                                         sphi_c, &
    6557             :                                         sphi_d, &
    6558             :                                         primitives, &
    6559           0 :                                         buffer1, buffer2)
    6560             : #endif
    6561             :                CASE (4)
    6562             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    6563             :                   CALL contract_ddgg(work, &
    6564             :                                      nl_a, nl_b, nl_c, nl_d, &
    6565             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    6566             :                                      primitives, &
    6567             :                                      buffer1, buffer2)
    6568             : #else
    6569             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    6570             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    6571             :                                         sphi_a, &
    6572             :                                         sphi_b, &
    6573             :                                         sphi_c, &
    6574             :                                         sphi_d, &
    6575             :                                         primitives, &
    6576           0 :                                         buffer1, buffer2)
    6577             : #endif
    6578             :                CASE DEFAULT
    6579             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    6580             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    6581             :                                         sphi_a, &
    6582             :                                         sphi_b, &
    6583             :                                         sphi_c, &
    6584             :                                         sphi_d, &
    6585             :                                         primitives, &
    6586           0 :                                         buffer1, buffer2)
    6587             :                END SELECT
    6588             :             CASE DEFAULT
    6589             :                CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    6590             :                                      work, nl_a, nl_b, nl_c, nl_d, &
    6591             :                                      sphi_a, &
    6592             :                                      sphi_b, &
    6593             :                                      sphi_c, &
    6594             :                                      sphi_d, &
    6595             :                                      primitives, &
    6596     1783882 :                                      buffer1, buffer2)
    6597             :             END SELECT
    6598             :          CASE (3)
    6599       40746 :             SELECT CASE (n_c)
    6600             :             CASE (0)
    6601       26916 :                SELECT CASE (n_d)
    6602             :                CASE (0)
    6603             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    6604             :                   CALL contract_dfss(work, &
    6605             :                                      nl_a, nl_b, nl_c, nl_d, &
    6606             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    6607             :                                      primitives, &
    6608             :                                      buffer1, buffer2)
    6609             : #else
    6610             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    6611             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    6612             :                                         sphi_a, &
    6613             :                                         sphi_b, &
    6614             :                                         sphi_c, &
    6615             :                                         sphi_d, &
    6616             :                                         primitives, &
    6617        4821 :                                         buffer1, buffer2)
    6618             : #endif
    6619             :                CASE (1)
    6620             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    6621             :                   CALL contract_dfsp(work, &
    6622             :                                      nl_a, nl_b, nl_c, nl_d, &
    6623             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    6624             :                                      primitives, &
    6625             :                                      buffer1, buffer2)
    6626             : #else
    6627             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    6628             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    6629             :                                         sphi_a, &
    6630             :                                         sphi_b, &
    6631             :                                         sphi_c, &
    6632             :                                         sphi_d, &
    6633             :                                         primitives, &
    6634        6337 :                                         buffer1, buffer2)
    6635             : #endif
    6636             :                CASE (2)
    6637             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    6638             :                   CALL contract_dfsd(work, &
    6639             :                                      nl_a, nl_b, nl_c, nl_d, &
    6640             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    6641             :                                      primitives, &
    6642             :                                      buffer1, buffer2)
    6643             : #else
    6644             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    6645             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    6646             :                                         sphi_a, &
    6647             :                                         sphi_b, &
    6648             :                                         sphi_c, &
    6649             :                                         sphi_d, &
    6650             :                                         primitives, &
    6651        1402 :                                         buffer1, buffer2)
    6652             : #endif
    6653             :                CASE (3)
    6654             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    6655             :                   CALL contract_dfsf(work, &
    6656             :                                      nl_a, nl_b, nl_c, nl_d, &
    6657             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    6658             :                                      primitives, &
    6659             :                                      buffer1, buffer2)
    6660             : #else
    6661             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    6662             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    6663             :                                         sphi_a, &
    6664             :                                         sphi_b, &
    6665             :                                         sphi_c, &
    6666             :                                         sphi_d, &
    6667             :                                         primitives, &
    6668        1569 :                                         buffer1, buffer2)
    6669             : #endif
    6670             :                CASE (4)
    6671             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    6672             :                   CALL contract_dfsg(work, &
    6673             :                                      nl_a, nl_b, nl_c, nl_d, &
    6674             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    6675             :                                      primitives, &
    6676             :                                      buffer1, buffer2)
    6677             : #else
    6678             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    6679             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    6680             :                                         sphi_a, &
    6681             :                                         sphi_b, &
    6682             :                                         sphi_c, &
    6683             :                                         sphi_d, &
    6684             :                                         primitives, &
    6685           0 :                                         buffer1, buffer2)
    6686             : #endif
    6687             :                CASE DEFAULT
    6688             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    6689             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    6690             :                                         sphi_a, &
    6691             :                                         sphi_b, &
    6692             :                                         sphi_c, &
    6693             :                                         sphi_d, &
    6694             :                                         primitives, &
    6695       14129 :                                         buffer1, buffer2)
    6696             :                END SELECT
    6697             :             CASE (1)
    6698       14449 :                SELECT CASE (n_d)
    6699             :                CASE (0)
    6700             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    6701             :                   CALL contract_dfps(work, &
    6702             :                                      nl_a, nl_b, nl_c, nl_d, &
    6703             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    6704             :                                      primitives, &
    6705             :                                      buffer1, buffer2)
    6706             : #else
    6707             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    6708             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    6709             :                                         sphi_a, &
    6710             :                                         sphi_b, &
    6711             :                                         sphi_c, &
    6712             :                                         sphi_d, &
    6713             :                                         primitives, &
    6714        3562 :                                         buffer1, buffer2)
    6715             : #endif
    6716             :                CASE (1)
    6717             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    6718             :                   CALL contract_dfpp(work, &
    6719             :                                      nl_a, nl_b, nl_c, nl_d, &
    6720             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    6721             :                                      primitives, &
    6722             :                                      buffer1, buffer2)
    6723             : #else
    6724             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    6725             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    6726             :                                         sphi_a, &
    6727             :                                         sphi_b, &
    6728             :                                         sphi_c, &
    6729             :                                         sphi_d, &
    6730             :                                         primitives, &
    6731        1751 :                                         buffer1, buffer2)
    6732             : #endif
    6733             :                CASE (2)
    6734             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    6735             :                   CALL contract_dfpd(work, &
    6736             :                                      nl_a, nl_b, nl_c, nl_d, &
    6737             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    6738             :                                      primitives, &
    6739             :                                      buffer1, buffer2)
    6740             : #else
    6741             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    6742             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    6743             :                                         sphi_a, &
    6744             :                                         sphi_b, &
    6745             :                                         sphi_c, &
    6746             :                                         sphi_d, &
    6747             :                                         primitives, &
    6748        2010 :                                         buffer1, buffer2)
    6749             : #endif
    6750             :                CASE (3)
    6751             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    6752             :                   CALL contract_dfpf(work, &
    6753             :                                      nl_a, nl_b, nl_c, nl_d, &
    6754             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    6755             :                                      primitives, &
    6756             :                                      buffer1, buffer2)
    6757             : #else
    6758             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    6759             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    6760             :                                         sphi_a, &
    6761             :                                         sphi_b, &
    6762             :                                         sphi_c, &
    6763             :                                         sphi_d, &
    6764             :                                         primitives, &
    6765         643 :                                         buffer1, buffer2)
    6766             : #endif
    6767             :                CASE (4)
    6768             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    6769             :                   CALL contract_dfpg(work, &
    6770             :                                      nl_a, nl_b, nl_c, nl_d, &
    6771             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    6772             :                                      primitives, &
    6773             :                                      buffer1, buffer2)
    6774             : #else
    6775             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    6776             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    6777             :                                         sphi_a, &
    6778             :                                         sphi_b, &
    6779             :                                         sphi_c, &
    6780             :                                         sphi_d, &
    6781             :                                         primitives, &
    6782           0 :                                         buffer1, buffer2)
    6783             : #endif
    6784             :                CASE DEFAULT
    6785             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    6786             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    6787             :                                         sphi_a, &
    6788             :                                         sphi_b, &
    6789             :                                         sphi_c, &
    6790             :                                         sphi_d, &
    6791             :                                         primitives, &
    6792        7966 :                                         buffer1, buffer2)
    6793             :                END SELECT
    6794             :             CASE (2)
    6795        5236 :                SELECT CASE (n_d)
    6796             :                CASE (0)
    6797             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    6798             :                   CALL contract_dfds(work, &
    6799             :                                      nl_a, nl_b, nl_c, nl_d, &
    6800             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    6801             :                                      primitives, &
    6802             :                                      buffer1, buffer2)
    6803             : #else
    6804             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    6805             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    6806             :                                         sphi_a, &
    6807             :                                         sphi_b, &
    6808             :                                         sphi_c, &
    6809             :                                         sphi_d, &
    6810             :                                         primitives, &
    6811         714 :                                         buffer1, buffer2)
    6812             : #endif
    6813             :                CASE (1)
    6814             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    6815             :                   CALL contract_dfdp(work, &
    6816             :                                      nl_a, nl_b, nl_c, nl_d, &
    6817             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    6818             :                                      primitives, &
    6819             :                                      buffer1, buffer2)
    6820             : #else
    6821             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    6822             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    6823             :                                         sphi_a, &
    6824             :                                         sphi_b, &
    6825             :                                         sphi_c, &
    6826             :                                         sphi_d, &
    6827             :                                         primitives, &
    6828        1111 :                                         buffer1, buffer2)
    6829             : #endif
    6830             :                CASE (2)
    6831             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    6832             :                   CALL contract_dfdd(work, &
    6833             :                                      nl_a, nl_b, nl_c, nl_d, &
    6834             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    6835             :                                      primitives, &
    6836             :                                      buffer1, buffer2)
    6837             : #else
    6838             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    6839             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    6840             :                                         sphi_a, &
    6841             :                                         sphi_b, &
    6842             :                                         sphi_c, &
    6843             :                                         sphi_d, &
    6844             :                                         primitives, &
    6845         495 :                                         buffer1, buffer2)
    6846             : #endif
    6847             :                CASE (3)
    6848             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    6849             :                   CALL contract_dfdf(work, &
    6850             :                                      nl_a, nl_b, nl_c, nl_d, &
    6851             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    6852             :                                      primitives, &
    6853             :                                      buffer1, buffer2)
    6854             : #else
    6855             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    6856             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    6857             :                                         sphi_a, &
    6858             :                                         sphi_b, &
    6859             :                                         sphi_c, &
    6860             :                                         sphi_d, &
    6861             :                                         primitives, &
    6862         601 :                                         buffer1, buffer2)
    6863             : #endif
    6864             :                CASE (4)
    6865             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    6866             :                   CALL contract_dfdg(work, &
    6867             :                                      nl_a, nl_b, nl_c, nl_d, &
    6868             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    6869             :                                      primitives, &
    6870             :                                      buffer1, buffer2)
    6871             : #else
    6872             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    6873             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    6874             :                                         sphi_a, &
    6875             :                                         sphi_b, &
    6876             :                                         sphi_c, &
    6877             :                                         sphi_d, &
    6878             :                                         primitives, &
    6879           0 :                                         buffer1, buffer2)
    6880             : #endif
    6881             :                CASE DEFAULT
    6882             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    6883             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    6884             :                                         sphi_a, &
    6885             :                                         sphi_b, &
    6886             :                                         sphi_c, &
    6887             :                                         sphi_d, &
    6888             :                                         primitives, &
    6889        2921 :                                         buffer1, buffer2)
    6890             :                END SELECT
    6891             :             CASE (3)
    6892        2303 :                SELECT CASE (n_d)
    6893             :                CASE (0)
    6894             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    6895             :                   CALL contract_dffs(work, &
    6896             :                                      nl_a, nl_b, nl_c, nl_d, &
    6897             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    6898             :                                      primitives, &
    6899             :                                      buffer1, buffer2)
    6900             : #else
    6901             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    6902             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    6903             :                                         sphi_a, &
    6904             :                                         sphi_b, &
    6905             :                                         sphi_c, &
    6906             :                                         sphi_d, &
    6907             :                                         primitives, &
    6908         702 :                                         buffer1, buffer2)
    6909             : #endif
    6910             :                CASE (1)
    6911             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    6912             :                   CALL contract_dffp(work, &
    6913             :                                      nl_a, nl_b, nl_c, nl_d, &
    6914             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    6915             :                                      primitives, &
    6916             :                                      buffer1, buffer2)
    6917             : #else
    6918             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    6919             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    6920             :                                         sphi_a, &
    6921             :                                         sphi_b, &
    6922             :                                         sphi_c, &
    6923             :                                         sphi_d, &
    6924             :                                         primitives, &
    6925         318 :                                         buffer1, buffer2)
    6926             : #endif
    6927             :                CASE (2)
    6928             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    6929             :                   CALL contract_dffd(work, &
    6930             :                                      nl_a, nl_b, nl_c, nl_d, &
    6931             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    6932             :                                      primitives, &
    6933             :                                      buffer1, buffer2)
    6934             : #else
    6935             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    6936             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    6937             :                                         sphi_a, &
    6938             :                                         sphi_b, &
    6939             :                                         sphi_c, &
    6940             :                                         sphi_d, &
    6941             :                                         primitives, &
    6942         333 :                                         buffer1, buffer2)
    6943             : #endif
    6944             :                CASE (3)
    6945             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    6946             :                   CALL contract_dfff(work, &
    6947             :                                      nl_a, nl_b, nl_c, nl_d, &
    6948             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    6949             :                                      primitives, &
    6950             :                                      buffer1, buffer2)
    6951             : #else
    6952             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    6953             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    6954             :                                         sphi_a, &
    6955             :                                         sphi_b, &
    6956             :                                         sphi_c, &
    6957             :                                         sphi_d, &
    6958             :                                         primitives, &
    6959         248 :                                         buffer1, buffer2)
    6960             : #endif
    6961             :                CASE (4)
    6962             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    6963             :                   CALL contract_dffg(work, &
    6964             :                                      nl_a, nl_b, nl_c, nl_d, &
    6965             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    6966             :                                      primitives, &
    6967             :                                      buffer1, buffer2)
    6968             : #else
    6969             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    6970             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    6971             :                                         sphi_a, &
    6972             :                                         sphi_b, &
    6973             :                                         sphi_c, &
    6974             :                                         sphi_d, &
    6975             :                                         primitives, &
    6976           0 :                                         buffer1, buffer2)
    6977             : #endif
    6978             :                CASE DEFAULT
    6979             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    6980             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    6981             :                                         sphi_a, &
    6982             :                                         sphi_b, &
    6983             :                                         sphi_c, &
    6984             :                                         sphi_d, &
    6985             :                                         primitives, &
    6986        1601 :                                         buffer1, buffer2)
    6987             :                END SELECT
    6988             :             CASE (4)
    6989           0 :                SELECT CASE (n_d)
    6990             :                CASE (0)
    6991             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    6992             :                   CALL contract_dfgs(work, &
    6993             :                                      nl_a, nl_b, nl_c, nl_d, &
    6994             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    6995             :                                      primitives, &
    6996             :                                      buffer1, buffer2)
    6997             : #else
    6998             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    6999             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    7000             :                                         sphi_a, &
    7001             :                                         sphi_b, &
    7002             :                                         sphi_c, &
    7003             :                                         sphi_d, &
    7004             :                                         primitives, &
    7005           0 :                                         buffer1, buffer2)
    7006             : #endif
    7007             :                CASE (1)
    7008             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    7009             :                   CALL contract_dfgp(work, &
    7010             :                                      nl_a, nl_b, nl_c, nl_d, &
    7011             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    7012             :                                      primitives, &
    7013             :                                      buffer1, buffer2)
    7014             : #else
    7015             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    7016             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    7017             :                                         sphi_a, &
    7018             :                                         sphi_b, &
    7019             :                                         sphi_c, &
    7020             :                                         sphi_d, &
    7021             :                                         primitives, &
    7022           0 :                                         buffer1, buffer2)
    7023             : #endif
    7024             :                CASE (2)
    7025             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    7026             :                   CALL contract_dfgd(work, &
    7027             :                                      nl_a, nl_b, nl_c, nl_d, &
    7028             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    7029             :                                      primitives, &
    7030             :                                      buffer1, buffer2)
    7031             : #else
    7032             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    7033             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    7034             :                                         sphi_a, &
    7035             :                                         sphi_b, &
    7036             :                                         sphi_c, &
    7037             :                                         sphi_d, &
    7038             :                                         primitives, &
    7039           0 :                                         buffer1, buffer2)
    7040             : #endif
    7041             :                CASE (3)
    7042             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    7043             :                   CALL contract_dfgf(work, &
    7044             :                                      nl_a, nl_b, nl_c, nl_d, &
    7045             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    7046             :                                      primitives, &
    7047             :                                      buffer1, buffer2)
    7048             : #else
    7049             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    7050             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    7051             :                                         sphi_a, &
    7052             :                                         sphi_b, &
    7053             :                                         sphi_c, &
    7054             :                                         sphi_d, &
    7055             :                                         primitives, &
    7056           0 :                                         buffer1, buffer2)
    7057             : #endif
    7058             :                CASE (4)
    7059             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    7060             :                   CALL contract_dfgg(work, &
    7061             :                                      nl_a, nl_b, nl_c, nl_d, &
    7062             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    7063             :                                      primitives, &
    7064             :                                      buffer1, buffer2)
    7065             : #else
    7066             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    7067             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    7068             :                                         sphi_a, &
    7069             :                                         sphi_b, &
    7070             :                                         sphi_c, &
    7071             :                                         sphi_d, &
    7072             :                                         primitives, &
    7073           0 :                                         buffer1, buffer2)
    7074             : #endif
    7075             :                CASE DEFAULT
    7076             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    7077             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    7078             :                                         sphi_a, &
    7079             :                                         sphi_b, &
    7080             :                                         sphi_c, &
    7081             :                                         sphi_d, &
    7082             :                                         primitives, &
    7083           0 :                                         buffer1, buffer2)
    7084             :                END SELECT
    7085             :             CASE DEFAULT
    7086             :                CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    7087             :                                      work, nl_a, nl_b, nl_c, nl_d, &
    7088             :                                      sphi_a, &
    7089             :                                      sphi_b, &
    7090             :                                      sphi_c, &
    7091             :                                      sphi_d, &
    7092             :                                      primitives, &
    7093       26617 :                                      buffer1, buffer2)
    7094             :             END SELECT
    7095             :          CASE (4)
    7096           0 :             SELECT CASE (n_c)
    7097             :             CASE (0)
    7098           0 :                SELECT CASE (n_d)
    7099             :                CASE (0)
    7100             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    7101             :                   CALL contract_dgss(work, &
    7102             :                                      nl_a, nl_b, nl_c, nl_d, &
    7103             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    7104             :                                      primitives, &
    7105             :                                      buffer1, buffer2)
    7106             : #else
    7107             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    7108             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    7109             :                                         sphi_a, &
    7110             :                                         sphi_b, &
    7111             :                                         sphi_c, &
    7112             :                                         sphi_d, &
    7113             :                                         primitives, &
    7114           0 :                                         buffer1, buffer2)
    7115             : #endif
    7116             :                CASE (1)
    7117             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    7118             :                   CALL contract_dgsp(work, &
    7119             :                                      nl_a, nl_b, nl_c, nl_d, &
    7120             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    7121             :                                      primitives, &
    7122             :                                      buffer1, buffer2)
    7123             : #else
    7124             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    7125             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    7126             :                                         sphi_a, &
    7127             :                                         sphi_b, &
    7128             :                                         sphi_c, &
    7129             :                                         sphi_d, &
    7130             :                                         primitives, &
    7131           0 :                                         buffer1, buffer2)
    7132             : #endif
    7133             :                CASE (2)
    7134             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    7135             :                   CALL contract_dgsd(work, &
    7136             :                                      nl_a, nl_b, nl_c, nl_d, &
    7137             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    7138             :                                      primitives, &
    7139             :                                      buffer1, buffer2)
    7140             : #else
    7141             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    7142             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    7143             :                                         sphi_a, &
    7144             :                                         sphi_b, &
    7145             :                                         sphi_c, &
    7146             :                                         sphi_d, &
    7147             :                                         primitives, &
    7148           0 :                                         buffer1, buffer2)
    7149             : #endif
    7150             :                CASE (3)
    7151             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    7152             :                   CALL contract_dgsf(work, &
    7153             :                                      nl_a, nl_b, nl_c, nl_d, &
    7154             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    7155             :                                      primitives, &
    7156             :                                      buffer1, buffer2)
    7157             : #else
    7158             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    7159             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    7160             :                                         sphi_a, &
    7161             :                                         sphi_b, &
    7162             :                                         sphi_c, &
    7163             :                                         sphi_d, &
    7164             :                                         primitives, &
    7165           0 :                                         buffer1, buffer2)
    7166             : #endif
    7167             :                CASE (4)
    7168             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    7169             :                   CALL contract_dgsg(work, &
    7170             :                                      nl_a, nl_b, nl_c, nl_d, &
    7171             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    7172             :                                      primitives, &
    7173             :                                      buffer1, buffer2)
    7174             : #else
    7175             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    7176             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    7177             :                                         sphi_a, &
    7178             :                                         sphi_b, &
    7179             :                                         sphi_c, &
    7180             :                                         sphi_d, &
    7181             :                                         primitives, &
    7182           0 :                                         buffer1, buffer2)
    7183             : #endif
    7184             :                CASE DEFAULT
    7185             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    7186             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    7187             :                                         sphi_a, &
    7188             :                                         sphi_b, &
    7189             :                                         sphi_c, &
    7190             :                                         sphi_d, &
    7191             :                                         primitives, &
    7192           0 :                                         buffer1, buffer2)
    7193             :                END SELECT
    7194             :             CASE (1)
    7195           0 :                SELECT CASE (n_d)
    7196             :                CASE (0)
    7197             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    7198             :                   CALL contract_dgps(work, &
    7199             :                                      nl_a, nl_b, nl_c, nl_d, &
    7200             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    7201             :                                      primitives, &
    7202             :                                      buffer1, buffer2)
    7203             : #else
    7204             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    7205             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    7206             :                                         sphi_a, &
    7207             :                                         sphi_b, &
    7208             :                                         sphi_c, &
    7209             :                                         sphi_d, &
    7210             :                                         primitives, &
    7211           0 :                                         buffer1, buffer2)
    7212             : #endif
    7213             :                CASE (1)
    7214             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    7215             :                   CALL contract_dgpp(work, &
    7216             :                                      nl_a, nl_b, nl_c, nl_d, &
    7217             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    7218             :                                      primitives, &
    7219             :                                      buffer1, buffer2)
    7220             : #else
    7221             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    7222             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    7223             :                                         sphi_a, &
    7224             :                                         sphi_b, &
    7225             :                                         sphi_c, &
    7226             :                                         sphi_d, &
    7227             :                                         primitives, &
    7228           0 :                                         buffer1, buffer2)
    7229             : #endif
    7230             :                CASE (2)
    7231             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    7232             :                   CALL contract_dgpd(work, &
    7233             :                                      nl_a, nl_b, nl_c, nl_d, &
    7234             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    7235             :                                      primitives, &
    7236             :                                      buffer1, buffer2)
    7237             : #else
    7238             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    7239             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    7240             :                                         sphi_a, &
    7241             :                                         sphi_b, &
    7242             :                                         sphi_c, &
    7243             :                                         sphi_d, &
    7244             :                                         primitives, &
    7245           0 :                                         buffer1, buffer2)
    7246             : #endif
    7247             :                CASE (3)
    7248             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    7249             :                   CALL contract_dgpf(work, &
    7250             :                                      nl_a, nl_b, nl_c, nl_d, &
    7251             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    7252             :                                      primitives, &
    7253             :                                      buffer1, buffer2)
    7254             : #else
    7255             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    7256             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    7257             :                                         sphi_a, &
    7258             :                                         sphi_b, &
    7259             :                                         sphi_c, &
    7260             :                                         sphi_d, &
    7261             :                                         primitives, &
    7262           0 :                                         buffer1, buffer2)
    7263             : #endif
    7264             :                CASE (4)
    7265             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    7266             :                   CALL contract_dgpg(work, &
    7267             :                                      nl_a, nl_b, nl_c, nl_d, &
    7268             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    7269             :                                      primitives, &
    7270             :                                      buffer1, buffer2)
    7271             : #else
    7272             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    7273             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    7274             :                                         sphi_a, &
    7275             :                                         sphi_b, &
    7276             :                                         sphi_c, &
    7277             :                                         sphi_d, &
    7278             :                                         primitives, &
    7279           0 :                                         buffer1, buffer2)
    7280             : #endif
    7281             :                CASE DEFAULT
    7282             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    7283             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    7284             :                                         sphi_a, &
    7285             :                                         sphi_b, &
    7286             :                                         sphi_c, &
    7287             :                                         sphi_d, &
    7288             :                                         primitives, &
    7289           0 :                                         buffer1, buffer2)
    7290             :                END SELECT
    7291             :             CASE (2)
    7292           0 :                SELECT CASE (n_d)
    7293             :                CASE (0)
    7294             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    7295             :                   CALL contract_dgds(work, &
    7296             :                                      nl_a, nl_b, nl_c, nl_d, &
    7297             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    7298             :                                      primitives, &
    7299             :                                      buffer1, buffer2)
    7300             : #else
    7301             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    7302             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    7303             :                                         sphi_a, &
    7304             :                                         sphi_b, &
    7305             :                                         sphi_c, &
    7306             :                                         sphi_d, &
    7307             :                                         primitives, &
    7308           0 :                                         buffer1, buffer2)
    7309             : #endif
    7310             :                CASE (1)
    7311             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    7312             :                   CALL contract_dgdp(work, &
    7313             :                                      nl_a, nl_b, nl_c, nl_d, &
    7314             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    7315             :                                      primitives, &
    7316             :                                      buffer1, buffer2)
    7317             : #else
    7318             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    7319             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    7320             :                                         sphi_a, &
    7321             :                                         sphi_b, &
    7322             :                                         sphi_c, &
    7323             :                                         sphi_d, &
    7324             :                                         primitives, &
    7325           0 :                                         buffer1, buffer2)
    7326             : #endif
    7327             :                CASE (2)
    7328             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    7329             :                   CALL contract_dgdd(work, &
    7330             :                                      nl_a, nl_b, nl_c, nl_d, &
    7331             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    7332             :                                      primitives, &
    7333             :                                      buffer1, buffer2)
    7334             : #else
    7335             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    7336             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    7337             :                                         sphi_a, &
    7338             :                                         sphi_b, &
    7339             :                                         sphi_c, &
    7340             :                                         sphi_d, &
    7341             :                                         primitives, &
    7342           0 :                                         buffer1, buffer2)
    7343             : #endif
    7344             :                CASE (3)
    7345             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    7346             :                   CALL contract_dgdf(work, &
    7347             :                                      nl_a, nl_b, nl_c, nl_d, &
    7348             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    7349             :                                      primitives, &
    7350             :                                      buffer1, buffer2)
    7351             : #else
    7352             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    7353             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    7354             :                                         sphi_a, &
    7355             :                                         sphi_b, &
    7356             :                                         sphi_c, &
    7357             :                                         sphi_d, &
    7358             :                                         primitives, &
    7359           0 :                                         buffer1, buffer2)
    7360             : #endif
    7361             :                CASE (4)
    7362             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    7363             :                   CALL contract_dgdg(work, &
    7364             :                                      nl_a, nl_b, nl_c, nl_d, &
    7365             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    7366             :                                      primitives, &
    7367             :                                      buffer1, buffer2)
    7368             : #else
    7369             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    7370             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    7371             :                                         sphi_a, &
    7372             :                                         sphi_b, &
    7373             :                                         sphi_c, &
    7374             :                                         sphi_d, &
    7375             :                                         primitives, &
    7376           0 :                                         buffer1, buffer2)
    7377             : #endif
    7378             :                CASE DEFAULT
    7379             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    7380             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    7381             :                                         sphi_a, &
    7382             :                                         sphi_b, &
    7383             :                                         sphi_c, &
    7384             :                                         sphi_d, &
    7385             :                                         primitives, &
    7386           0 :                                         buffer1, buffer2)
    7387             :                END SELECT
    7388             :             CASE (3)
    7389           0 :                SELECT CASE (n_d)
    7390             :                CASE (0)
    7391             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    7392             :                   CALL contract_dgfs(work, &
    7393             :                                      nl_a, nl_b, nl_c, nl_d, &
    7394             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    7395             :                                      primitives, &
    7396             :                                      buffer1, buffer2)
    7397             : #else
    7398             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    7399             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    7400             :                                         sphi_a, &
    7401             :                                         sphi_b, &
    7402             :                                         sphi_c, &
    7403             :                                         sphi_d, &
    7404             :                                         primitives, &
    7405           0 :                                         buffer1, buffer2)
    7406             : #endif
    7407             :                CASE (1)
    7408             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    7409             :                   CALL contract_dgfp(work, &
    7410             :                                      nl_a, nl_b, nl_c, nl_d, &
    7411             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    7412             :                                      primitives, &
    7413             :                                      buffer1, buffer2)
    7414             : #else
    7415             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    7416             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    7417             :                                         sphi_a, &
    7418             :                                         sphi_b, &
    7419             :                                         sphi_c, &
    7420             :                                         sphi_d, &
    7421             :                                         primitives, &
    7422           0 :                                         buffer1, buffer2)
    7423             : #endif
    7424             :                CASE (2)
    7425             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    7426             :                   CALL contract_dgfd(work, &
    7427             :                                      nl_a, nl_b, nl_c, nl_d, &
    7428             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    7429             :                                      primitives, &
    7430             :                                      buffer1, buffer2)
    7431             : #else
    7432             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    7433             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    7434             :                                         sphi_a, &
    7435             :                                         sphi_b, &
    7436             :                                         sphi_c, &
    7437             :                                         sphi_d, &
    7438             :                                         primitives, &
    7439           0 :                                         buffer1, buffer2)
    7440             : #endif
    7441             :                CASE (3)
    7442             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    7443             :                   CALL contract_dgff(work, &
    7444             :                                      nl_a, nl_b, nl_c, nl_d, &
    7445             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    7446             :                                      primitives, &
    7447             :                                      buffer1, buffer2)
    7448             : #else
    7449             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    7450             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    7451             :                                         sphi_a, &
    7452             :                                         sphi_b, &
    7453             :                                         sphi_c, &
    7454             :                                         sphi_d, &
    7455             :                                         primitives, &
    7456           0 :                                         buffer1, buffer2)
    7457             : #endif
    7458             :                CASE (4)
    7459             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    7460             :                   CALL contract_dgfg(work, &
    7461             :                                      nl_a, nl_b, nl_c, nl_d, &
    7462             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    7463             :                                      primitives, &
    7464             :                                      buffer1, buffer2)
    7465             : #else
    7466             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    7467             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    7468             :                                         sphi_a, &
    7469             :                                         sphi_b, &
    7470             :                                         sphi_c, &
    7471             :                                         sphi_d, &
    7472             :                                         primitives, &
    7473           0 :                                         buffer1, buffer2)
    7474             : #endif
    7475             :                CASE DEFAULT
    7476             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    7477             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    7478             :                                         sphi_a, &
    7479             :                                         sphi_b, &
    7480             :                                         sphi_c, &
    7481             :                                         sphi_d, &
    7482             :                                         primitives, &
    7483           0 :                                         buffer1, buffer2)
    7484             :                END SELECT
    7485             :             CASE (4)
    7486           0 :                SELECT CASE (n_d)
    7487             :                CASE (0)
    7488             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    7489             :                   CALL contract_dggs(work, &
    7490             :                                      nl_a, nl_b, nl_c, nl_d, &
    7491             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    7492             :                                      primitives, &
    7493             :                                      buffer1, buffer2)
    7494             : #else
    7495             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    7496             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    7497             :                                         sphi_a, &
    7498             :                                         sphi_b, &
    7499             :                                         sphi_c, &
    7500             :                                         sphi_d, &
    7501             :                                         primitives, &
    7502           0 :                                         buffer1, buffer2)
    7503             : #endif
    7504             :                CASE (1)
    7505             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    7506             :                   CALL contract_dggp(work, &
    7507             :                                      nl_a, nl_b, nl_c, nl_d, &
    7508             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    7509             :                                      primitives, &
    7510             :                                      buffer1, buffer2)
    7511             : #else
    7512             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    7513             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    7514             :                                         sphi_a, &
    7515             :                                         sphi_b, &
    7516             :                                         sphi_c, &
    7517             :                                         sphi_d, &
    7518             :                                         primitives, &
    7519           0 :                                         buffer1, buffer2)
    7520             : #endif
    7521             :                CASE (2)
    7522             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    7523             :                   CALL contract_dggd(work, &
    7524             :                                      nl_a, nl_b, nl_c, nl_d, &
    7525             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    7526             :                                      primitives, &
    7527             :                                      buffer1, buffer2)
    7528             : #else
    7529             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    7530             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    7531             :                                         sphi_a, &
    7532             :                                         sphi_b, &
    7533             :                                         sphi_c, &
    7534             :                                         sphi_d, &
    7535             :                                         primitives, &
    7536           0 :                                         buffer1, buffer2)
    7537             : #endif
    7538             :                CASE (3)
    7539             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    7540             :                   CALL contract_dggf(work, &
    7541             :                                      nl_a, nl_b, nl_c, nl_d, &
    7542             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    7543             :                                      primitives, &
    7544             :                                      buffer1, buffer2)
    7545             : #else
    7546             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    7547             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    7548             :                                         sphi_a, &
    7549             :                                         sphi_b, &
    7550             :                                         sphi_c, &
    7551             :                                         sphi_d, &
    7552             :                                         primitives, &
    7553           0 :                                         buffer1, buffer2)
    7554             : #endif
    7555             :                CASE (4)
    7556             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    7557             :                   CALL contract_dggg(work, &
    7558             :                                      nl_a, nl_b, nl_c, nl_d, &
    7559             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    7560             :                                      primitives, &
    7561             :                                      buffer1, buffer2)
    7562             : #else
    7563             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    7564             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    7565             :                                         sphi_a, &
    7566             :                                         sphi_b, &
    7567             :                                         sphi_c, &
    7568             :                                         sphi_d, &
    7569             :                                         primitives, &
    7570           0 :                                         buffer1, buffer2)
    7571             : #endif
    7572             :                CASE DEFAULT
    7573             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    7574             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    7575             :                                         sphi_a, &
    7576             :                                         sphi_b, &
    7577             :                                         sphi_c, &
    7578             :                                         sphi_d, &
    7579             :                                         primitives, &
    7580           0 :                                         buffer1, buffer2)
    7581             :                END SELECT
    7582             :             CASE DEFAULT
    7583             :                CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    7584             :                                      work, nl_a, nl_b, nl_c, nl_d, &
    7585             :                                      sphi_a, &
    7586             :                                      sphi_b, &
    7587             :                                      sphi_c, &
    7588             :                                      sphi_d, &
    7589             :                                      primitives, &
    7590           0 :                                      buffer1, buffer2)
    7591             :             END SELECT
    7592             :          CASE DEFAULT
    7593             :             CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    7594             :                                   work, nl_a, nl_b, nl_c, nl_d, &
    7595             :                                   sphi_a, &
    7596             :                                   sphi_b, &
    7597             :                                   sphi_c, &
    7598             :                                   sphi_d, &
    7599             :                                   primitives, &
    7600    14687667 :                                   buffer1, buffer2)
    7601             :          END SELECT
    7602             :       CASE (3)
    7603      449715 :          SELECT CASE (n_b)
    7604             :          CASE (0)
    7605      313490 :             SELECT CASE (n_c)
    7606             :             CASE (0)
    7607      187514 :                SELECT CASE (n_d)
    7608             :                CASE (0)
    7609             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    7610             :                   CALL contract_fsss(work, &
    7611             :                                      nl_a, nl_b, nl_c, nl_d, &
    7612             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    7613             :                                      primitives, &
    7614             :                                      buffer1, buffer2)
    7615             : #else
    7616             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    7617             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    7618             :                                         sphi_a, &
    7619             :                                         sphi_b, &
    7620             :                                         sphi_c, &
    7621             :                                         sphi_d, &
    7622             :                                         primitives, &
    7623       20006 :                                         buffer1, buffer2)
    7624             : #endif
    7625             :                CASE (1)
    7626             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    7627             :                   CALL contract_fssp(work, &
    7628             :                                      nl_a, nl_b, nl_c, nl_d, &
    7629             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    7630             :                                      primitives, &
    7631             :                                      buffer1, buffer2)
    7632             : #else
    7633             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    7634             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    7635             :                                         sphi_a, &
    7636             :                                         sphi_b, &
    7637             :                                         sphi_c, &
    7638             :                                         sphi_d, &
    7639             :                                         primitives, &
    7640       58207 :                                         buffer1, buffer2)
    7641             : #endif
    7642             :                CASE (2)
    7643             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    7644             :                   CALL contract_fssd(work, &
    7645             :                                      nl_a, nl_b, nl_c, nl_d, &
    7646             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    7647             :                                      primitives, &
    7648             :                                      buffer1, buffer2)
    7649             : #else
    7650             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    7651             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    7652             :                                         sphi_a, &
    7653             :                                         sphi_b, &
    7654             :                                         sphi_c, &
    7655             :                                         sphi_d, &
    7656             :                                         primitives, &
    7657        3144 :                                         buffer1, buffer2)
    7658             : #endif
    7659             :                CASE (3)
    7660             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    7661             :                   CALL contract_fssf(work, &
    7662             :                                      nl_a, nl_b, nl_c, nl_d, &
    7663             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    7664             :                                      primitives, &
    7665             :                                      buffer1, buffer2)
    7666             : #else
    7667             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    7668             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    7669             :                                         sphi_a, &
    7670             :                                         sphi_b, &
    7671             :                                         sphi_c, &
    7672             :                                         sphi_d, &
    7673             :                                         primitives, &
    7674        2268 :                                         buffer1, buffer2)
    7675             : #endif
    7676             :                CASE (4)
    7677             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    7678             :                   CALL contract_fssg(work, &
    7679             :                                      nl_a, nl_b, nl_c, nl_d, &
    7680             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    7681             :                                      primitives, &
    7682             :                                      buffer1, buffer2)
    7683             : #else
    7684             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    7685             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    7686             :                                         sphi_a, &
    7687             :                                         sphi_b, &
    7688             :                                         sphi_c, &
    7689             :                                         sphi_d, &
    7690             :                                         primitives, &
    7691           0 :                                         buffer1, buffer2)
    7692             : #endif
    7693             :                CASE DEFAULT
    7694             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    7695             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    7696             :                                         sphi_a, &
    7697             :                                         sphi_b, &
    7698             :                                         sphi_c, &
    7699             :                                         sphi_d, &
    7700             :                                         primitives, &
    7701       83625 :                                         buffer1, buffer2)
    7702             :                END SELECT
    7703             :             CASE (1)
    7704      153002 :                SELECT CASE (n_d)
    7705             :                CASE (0)
    7706             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    7707             :                   CALL contract_fsps(work, &
    7708             :                                      nl_a, nl_b, nl_c, nl_d, &
    7709             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    7710             :                                      primitives, &
    7711             :                                      buffer1, buffer2)
    7712             : #else
    7713             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    7714             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    7715             :                                         sphi_a, &
    7716             :                                         sphi_b, &
    7717             :                                         sphi_c, &
    7718             :                                         sphi_d, &
    7719             :                                         primitives, &
    7720       59394 :                                         buffer1, buffer2)
    7721             : #endif
    7722             :                CASE (1)
    7723             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    7724             :                   CALL contract_fspp(work, &
    7725             :                                      nl_a, nl_b, nl_c, nl_d, &
    7726             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    7727             :                                      primitives, &
    7728             :                                      buffer1, buffer2)
    7729             : #else
    7730             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    7731             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    7732             :                                         sphi_a, &
    7733             :                                         sphi_b, &
    7734             :                                         sphi_c, &
    7735             :                                         sphi_d, &
    7736             :                                         primitives, &
    7737        6426 :                                         buffer1, buffer2)
    7738             : #endif
    7739             :                CASE (2)
    7740             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    7741             :                   CALL contract_fspd(work, &
    7742             :                                      nl_a, nl_b, nl_c, nl_d, &
    7743             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    7744             :                                      primitives, &
    7745             :                                      buffer1, buffer2)
    7746             : #else
    7747             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    7748             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    7749             :                                         sphi_a, &
    7750             :                                         sphi_b, &
    7751             :                                         sphi_c, &
    7752             :                                         sphi_d, &
    7753             :                                         primitives, &
    7754       16997 :                                         buffer1, buffer2)
    7755             : #endif
    7756             :                CASE (3)
    7757             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    7758             :                   CALL contract_fspf(work, &
    7759             :                                      nl_a, nl_b, nl_c, nl_d, &
    7760             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    7761             :                                      primitives, &
    7762             :                                      buffer1, buffer2)
    7763             : #else
    7764             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    7765             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    7766             :                                         sphi_a, &
    7767             :                                         sphi_b, &
    7768             :                                         sphi_c, &
    7769             :                                         sphi_d, &
    7770             :                                         primitives, &
    7771        1066 :                                         buffer1, buffer2)
    7772             : #endif
    7773             :                CASE (4)
    7774             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    7775             :                   CALL contract_fspg(work, &
    7776             :                                      nl_a, nl_b, nl_c, nl_d, &
    7777             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    7778             :                                      primitives, &
    7779             :                                      buffer1, buffer2)
    7780             : #else
    7781             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    7782             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    7783             :                                         sphi_a, &
    7784             :                                         sphi_b, &
    7785             :                                         sphi_c, &
    7786             :                                         sphi_d, &
    7787             :                                         primitives, &
    7788           0 :                                         buffer1, buffer2)
    7789             : #endif
    7790             :                CASE DEFAULT
    7791             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    7792             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    7793             :                                         sphi_a, &
    7794             :                                         sphi_b, &
    7795             :                                         sphi_c, &
    7796             :                                         sphi_d, &
    7797             :                                         primitives, &
    7798       83883 :                                         buffer1, buffer2)
    7799             :                END SELECT
    7800             :             CASE (2)
    7801       22254 :                SELECT CASE (n_d)
    7802             :                CASE (0)
    7803             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    7804             :                   CALL contract_fsds(work, &
    7805             :                                      nl_a, nl_b, nl_c, nl_d, &
    7806             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    7807             :                                      primitives, &
    7808             :                                      buffer1, buffer2)
    7809             : #else
    7810             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    7811             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    7812             :                                         sphi_a, &
    7813             :                                         sphi_b, &
    7814             :                                         sphi_c, &
    7815             :                                         sphi_d, &
    7816             :                                         primitives, &
    7817        4235 :                                         buffer1, buffer2)
    7818             : #endif
    7819             :                CASE (1)
    7820             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    7821             :                   CALL contract_fsdp(work, &
    7822             :                                      nl_a, nl_b, nl_c, nl_d, &
    7823             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    7824             :                                      primitives, &
    7825             :                                      buffer1, buffer2)
    7826             : #else
    7827             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    7828             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    7829             :                                         sphi_a, &
    7830             :                                         sphi_b, &
    7831             :                                         sphi_c, &
    7832             :                                         sphi_d, &
    7833             :                                         primitives, &
    7834        3685 :                                         buffer1, buffer2)
    7835             : #endif
    7836             :                CASE (2)
    7837             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    7838             :                   CALL contract_fsdd(work, &
    7839             :                                      nl_a, nl_b, nl_c, nl_d, &
    7840             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    7841             :                                      primitives, &
    7842             :                                      buffer1, buffer2)
    7843             : #else
    7844             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    7845             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    7846             :                                         sphi_a, &
    7847             :                                         sphi_b, &
    7848             :                                         sphi_c, &
    7849             :                                         sphi_d, &
    7850             :                                         primitives, &
    7851         957 :                                         buffer1, buffer2)
    7852             : #endif
    7853             :                CASE (3)
    7854             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    7855             :                   CALL contract_fsdf(work, &
    7856             :                                      nl_a, nl_b, nl_c, nl_d, &
    7857             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    7858             :                                      primitives, &
    7859             :                                      buffer1, buffer2)
    7860             : #else
    7861             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    7862             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    7863             :                                         sphi_a, &
    7864             :                                         sphi_b, &
    7865             :                                         sphi_c, &
    7866             :                                         sphi_d, &
    7867             :                                         primitives, &
    7868         848 :                                         buffer1, buffer2)
    7869             : #endif
    7870             :                CASE (4)
    7871             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    7872             :                   CALL contract_fsdg(work, &
    7873             :                                      nl_a, nl_b, nl_c, nl_d, &
    7874             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    7875             :                                      primitives, &
    7876             :                                      buffer1, buffer2)
    7877             : #else
    7878             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    7879             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    7880             :                                         sphi_a, &
    7881             :                                         sphi_b, &
    7882             :                                         sphi_c, &
    7883             :                                         sphi_d, &
    7884             :                                         primitives, &
    7885           0 :                                         buffer1, buffer2)
    7886             : #endif
    7887             :                CASE DEFAULT
    7888             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    7889             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    7890             :                                         sphi_a, &
    7891             :                                         sphi_b, &
    7892             :                                         sphi_c, &
    7893             :                                         sphi_d, &
    7894             :                                         primitives, &
    7895        9725 :                                         buffer1, buffer2)
    7896             :                END SELECT
    7897             :             CASE (3)
    7898       14621 :                SELECT CASE (n_d)
    7899             :                CASE (0)
    7900             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    7901             :                   CALL contract_fsfs(work, &
    7902             :                                      nl_a, nl_b, nl_c, nl_d, &
    7903             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    7904             :                                      primitives, &
    7905             :                                      buffer1, buffer2)
    7906             : #else
    7907             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    7908             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    7909             :                                         sphi_a, &
    7910             :                                         sphi_b, &
    7911             :                                         sphi_c, &
    7912             :                                         sphi_d, &
    7913             :                                         primitives, &
    7914        6327 :                                         buffer1, buffer2)
    7915             : #endif
    7916             :                CASE (1)
    7917             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    7918             :                   CALL contract_fsfp(work, &
    7919             :                                      nl_a, nl_b, nl_c, nl_d, &
    7920             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    7921             :                                      primitives, &
    7922             :                                      buffer1, buffer2)
    7923             : #else
    7924             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    7925             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    7926             :                                         sphi_a, &
    7927             :                                         sphi_b, &
    7928             :                                         sphi_c, &
    7929             :                                         sphi_d, &
    7930             :                                         primitives, &
    7931         962 :                                         buffer1, buffer2)
    7932             : #endif
    7933             :                CASE (2)
    7934             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    7935             :                   CALL contract_fsfd(work, &
    7936             :                                      nl_a, nl_b, nl_c, nl_d, &
    7937             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    7938             :                                      primitives, &
    7939             :                                      buffer1, buffer2)
    7940             : #else
    7941             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    7942             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    7943             :                                         sphi_a, &
    7944             :                                         sphi_b, &
    7945             :                                         sphi_c, &
    7946             :                                         sphi_d, &
    7947             :                                         primitives, &
    7948         727 :                                         buffer1, buffer2)
    7949             : #endif
    7950             :                CASE (3)
    7951             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    7952             :                   CALL contract_fsff(work, &
    7953             :                                      nl_a, nl_b, nl_c, nl_d, &
    7954             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    7955             :                                      primitives, &
    7956             :                                      buffer1, buffer2)
    7957             : #else
    7958             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    7959             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    7960             :                                         sphi_a, &
    7961             :                                         sphi_b, &
    7962             :                                         sphi_c, &
    7963             :                                         sphi_d, &
    7964             :                                         primitives, &
    7965         278 :                                         buffer1, buffer2)
    7966             : #endif
    7967             :                CASE (4)
    7968             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    7969             :                   CALL contract_fsfg(work, &
    7970             :                                      nl_a, nl_b, nl_c, nl_d, &
    7971             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    7972             :                                      primitives, &
    7973             :                                      buffer1, buffer2)
    7974             : #else
    7975             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    7976             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    7977             :                                         sphi_a, &
    7978             :                                         sphi_b, &
    7979             :                                         sphi_c, &
    7980             :                                         sphi_d, &
    7981             :                                         primitives, &
    7982           0 :                                         buffer1, buffer2)
    7983             : #endif
    7984             :                CASE DEFAULT
    7985             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    7986             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    7987             :                                         sphi_a, &
    7988             :                                         sphi_b, &
    7989             :                                         sphi_c, &
    7990             :                                         sphi_d, &
    7991             :                                         primitives, &
    7992        8294 :                                         buffer1, buffer2)
    7993             :                END SELECT
    7994             :             CASE (4)
    7995           0 :                SELECT CASE (n_d)
    7996             :                CASE (0)
    7997             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    7998             :                   CALL contract_fsgs(work, &
    7999             :                                      nl_a, nl_b, nl_c, nl_d, &
    8000             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    8001             :                                      primitives, &
    8002             :                                      buffer1, buffer2)
    8003             : #else
    8004             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    8005             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    8006             :                                         sphi_a, &
    8007             :                                         sphi_b, &
    8008             :                                         sphi_c, &
    8009             :                                         sphi_d, &
    8010             :                                         primitives, &
    8011           0 :                                         buffer1, buffer2)
    8012             : #endif
    8013             :                CASE (1)
    8014             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    8015             :                   CALL contract_fsgp(work, &
    8016             :                                      nl_a, nl_b, nl_c, nl_d, &
    8017             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    8018             :                                      primitives, &
    8019             :                                      buffer1, buffer2)
    8020             : #else
    8021             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    8022             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    8023             :                                         sphi_a, &
    8024             :                                         sphi_b, &
    8025             :                                         sphi_c, &
    8026             :                                         sphi_d, &
    8027             :                                         primitives, &
    8028           0 :                                         buffer1, buffer2)
    8029             : #endif
    8030             :                CASE (2)
    8031             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    8032             :                   CALL contract_fsgd(work, &
    8033             :                                      nl_a, nl_b, nl_c, nl_d, &
    8034             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    8035             :                                      primitives, &
    8036             :                                      buffer1, buffer2)
    8037             : #else
    8038             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    8039             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    8040             :                                         sphi_a, &
    8041             :                                         sphi_b, &
    8042             :                                         sphi_c, &
    8043             :                                         sphi_d, &
    8044             :                                         primitives, &
    8045           0 :                                         buffer1, buffer2)
    8046             : #endif
    8047             :                CASE (3)
    8048             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    8049             :                   CALL contract_fsgf(work, &
    8050             :                                      nl_a, nl_b, nl_c, nl_d, &
    8051             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    8052             :                                      primitives, &
    8053             :                                      buffer1, buffer2)
    8054             : #else
    8055             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    8056             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    8057             :                                         sphi_a, &
    8058             :                                         sphi_b, &
    8059             :                                         sphi_c, &
    8060             :                                         sphi_d, &
    8061             :                                         primitives, &
    8062           0 :                                         buffer1, buffer2)
    8063             : #endif
    8064             :                CASE (4)
    8065             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    8066             :                   CALL contract_fsgg(work, &
    8067             :                                      nl_a, nl_b, nl_c, nl_d, &
    8068             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    8069             :                                      primitives, &
    8070             :                                      buffer1, buffer2)
    8071             : #else
    8072             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    8073             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    8074             :                                         sphi_a, &
    8075             :                                         sphi_b, &
    8076             :                                         sphi_c, &
    8077             :                                         sphi_d, &
    8078             :                                         primitives, &
    8079           0 :                                         buffer1, buffer2)
    8080             : #endif
    8081             :                CASE DEFAULT
    8082             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    8083             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    8084             :                                         sphi_a, &
    8085             :                                         sphi_b, &
    8086             :                                         sphi_c, &
    8087             :                                         sphi_d, &
    8088             :                                         primitives, &
    8089           0 :                                         buffer1, buffer2)
    8090             :                END SELECT
    8091             :             CASE DEFAULT
    8092             :                CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    8093             :                                      work, nl_a, nl_b, nl_c, nl_d, &
    8094             :                                      sphi_a, &
    8095             :                                      sphi_b, &
    8096             :                                      sphi_c, &
    8097             :                                      sphi_d, &
    8098             :                                      primitives, &
    8099      185527 :                                      buffer1, buffer2)
    8100             :             END SELECT
    8101             :          CASE (1)
    8102       86136 :             SELECT CASE (n_c)
    8103             :             CASE (0)
    8104       52558 :                SELECT CASE (n_d)
    8105             :                CASE (0)
    8106             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    8107             :                   CALL contract_fpss(work, &
    8108             :                                      nl_a, nl_b, nl_c, nl_d, &
    8109             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    8110             :                                      primitives, &
    8111             :                                      buffer1, buffer2)
    8112             : #else
    8113             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    8114             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    8115             :                                         sphi_a, &
    8116             :                                         sphi_b, &
    8117             :                                         sphi_c, &
    8118             :                                         sphi_d, &
    8119             :                                         primitives, &
    8120       16169 :                                         buffer1, buffer2)
    8121             : #endif
    8122             :                CASE (1)
    8123             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    8124             :                   CALL contract_fpsp(work, &
    8125             :                                      nl_a, nl_b, nl_c, nl_d, &
    8126             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    8127             :                                      primitives, &
    8128             :                                      buffer1, buffer2)
    8129             : #else
    8130             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    8131             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    8132             :                                         sphi_a, &
    8133             :                                         sphi_b, &
    8134             :                                         sphi_c, &
    8135             :                                         sphi_d, &
    8136             :                                         primitives, &
    8137        4023 :                                         buffer1, buffer2)
    8138             : #endif
    8139             :                CASE (2)
    8140             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    8141             :                   CALL contract_fpsd(work, &
    8142             :                                      nl_a, nl_b, nl_c, nl_d, &
    8143             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    8144             :                                      primitives, &
    8145             :                                      buffer1, buffer2)
    8146             : #else
    8147             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    8148             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    8149             :                                         sphi_a, &
    8150             :                                         sphi_b, &
    8151             :                                         sphi_c, &
    8152             :                                         sphi_d, &
    8153             :                                         primitives, &
    8154        3633 :                                         buffer1, buffer2)
    8155             : #endif
    8156             :                CASE (3)
    8157             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    8158             :                   CALL contract_fpsf(work, &
    8159             :                                      nl_a, nl_b, nl_c, nl_d, &
    8160             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    8161             :                                      primitives, &
    8162             :                                      buffer1, buffer2)
    8163             : #else
    8164             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    8165             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    8166             :                                         sphi_a, &
    8167             :                                         sphi_b, &
    8168             :                                         sphi_c, &
    8169             :                                         sphi_d, &
    8170             :                                         primitives, &
    8171         822 :                                         buffer1, buffer2)
    8172             : #endif
    8173             :                CASE (4)
    8174             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    8175             :                   CALL contract_fpsg(work, &
    8176             :                                      nl_a, nl_b, nl_c, nl_d, &
    8177             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    8178             :                                      primitives, &
    8179             :                                      buffer1, buffer2)
    8180             : #else
    8181             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    8182             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    8183             :                                         sphi_a, &
    8184             :                                         sphi_b, &
    8185             :                                         sphi_c, &
    8186             :                                         sphi_d, &
    8187             :                                         primitives, &
    8188           0 :                                         buffer1, buffer2)
    8189             : #endif
    8190             :                CASE DEFAULT
    8191             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    8192             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    8193             :                                         sphi_a, &
    8194             :                                         sphi_b, &
    8195             :                                         sphi_c, &
    8196             :                                         sphi_d, &
    8197             :                                         primitives, &
    8198       24647 :                                         buffer1, buffer2)
    8199             :                END SELECT
    8200             :             CASE (1)
    8201       21066 :                SELECT CASE (n_d)
    8202             :                CASE (0)
    8203             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    8204             :                   CALL contract_fpps(work, &
    8205             :                                      nl_a, nl_b, nl_c, nl_d, &
    8206             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    8207             :                                      primitives, &
    8208             :                                      buffer1, buffer2)
    8209             : #else
    8210             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    8211             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    8212             :                                         sphi_a, &
    8213             :                                         sphi_b, &
    8214             :                                         sphi_c, &
    8215             :                                         sphi_d, &
    8216             :                                         primitives, &
    8217        3665 :                                         buffer1, buffer2)
    8218             : #endif
    8219             :                CASE (1)
    8220             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    8221             :                   CALL contract_fppp(work, &
    8222             :                                      nl_a, nl_b, nl_c, nl_d, &
    8223             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    8224             :                                      primitives, &
    8225             :                                      buffer1, buffer2)
    8226             : #else
    8227             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    8228             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    8229             :                                         sphi_a, &
    8230             :                                         sphi_b, &
    8231             :                                         sphi_c, &
    8232             :                                         sphi_d, &
    8233             :                                         primitives, &
    8234        5563 :                                         buffer1, buffer2)
    8235             : #endif
    8236             :                CASE (2)
    8237             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    8238             :                   CALL contract_fppd(work, &
    8239             :                                      nl_a, nl_b, nl_c, nl_d, &
    8240             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    8241             :                                      primitives, &
    8242             :                                      buffer1, buffer2)
    8243             : #else
    8244             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    8245             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    8246             :                                         sphi_a, &
    8247             :                                         sphi_b, &
    8248             :                                         sphi_c, &
    8249             :                                         sphi_d, &
    8250             :                                         primitives, &
    8251        1249 :                                         buffer1, buffer2)
    8252             : #endif
    8253             :                CASE (3)
    8254             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    8255             :                   CALL contract_fppf(work, &
    8256             :                                      nl_a, nl_b, nl_c, nl_d, &
    8257             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    8258             :                                      primitives, &
    8259             :                                      buffer1, buffer2)
    8260             : #else
    8261             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    8262             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    8263             :                                         sphi_a, &
    8264             :                                         sphi_b, &
    8265             :                                         sphi_c, &
    8266             :                                         sphi_d, &
    8267             :                                         primitives, &
    8268        1265 :                                         buffer1, buffer2)
    8269             : #endif
    8270             :                CASE (4)
    8271             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    8272             :                   CALL contract_fppg(work, &
    8273             :                                      nl_a, nl_b, nl_c, nl_d, &
    8274             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    8275             :                                      primitives, &
    8276             :                                      buffer1, buffer2)
    8277             : #else
    8278             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    8279             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    8280             :                                         sphi_a, &
    8281             :                                         sphi_b, &
    8282             :                                         sphi_c, &
    8283             :                                         sphi_d, &
    8284             :                                         primitives, &
    8285           0 :                                         buffer1, buffer2)
    8286             : #endif
    8287             :                CASE DEFAULT
    8288             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    8289             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    8290             :                                         sphi_a, &
    8291             :                                         sphi_b, &
    8292             :                                         sphi_c, &
    8293             :                                         sphi_d, &
    8294             :                                         primitives, &
    8295       11742 :                                         buffer1, buffer2)
    8296             :                END SELECT
    8297             :             CASE (2)
    8298       11196 :                SELECT CASE (n_d)
    8299             :                CASE (0)
    8300             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    8301             :                   CALL contract_fpds(work, &
    8302             :                                      nl_a, nl_b, nl_c, nl_d, &
    8303             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    8304             :                                      primitives, &
    8305             :                                      buffer1, buffer2)
    8306             : #else
    8307             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    8308             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    8309             :                                         sphi_a, &
    8310             :                                         sphi_b, &
    8311             :                                         sphi_c, &
    8312             :                                         sphi_d, &
    8313             :                                         primitives, &
    8314        3247 :                                         buffer1, buffer2)
    8315             : #endif
    8316             :                CASE (1)
    8317             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    8318             :                   CALL contract_fpdp(work, &
    8319             :                                      nl_a, nl_b, nl_c, nl_d, &
    8320             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    8321             :                                      primitives, &
    8322             :                                      buffer1, buffer2)
    8323             : #else
    8324             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    8325             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    8326             :                                         sphi_a, &
    8327             :                                         sphi_b, &
    8328             :                                         sphi_c, &
    8329             :                                         sphi_d, &
    8330             :                                         primitives, &
    8331         985 :                                         buffer1, buffer2)
    8332             : #endif
    8333             :                CASE (2)
    8334             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    8335             :                   CALL contract_fpdd(work, &
    8336             :                                      nl_a, nl_b, nl_c, nl_d, &
    8337             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    8338             :                                      primitives, &
    8339             :                                      buffer1, buffer2)
    8340             : #else
    8341             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    8342             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    8343             :                                         sphi_a, &
    8344             :                                         sphi_b, &
    8345             :                                         sphi_c, &
    8346             :                                         sphi_d, &
    8347             :                                         primitives, &
    8348        1077 :                                         buffer1, buffer2)
    8349             : #endif
    8350             :                CASE (3)
    8351             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    8352             :                   CALL contract_fpdf(work, &
    8353             :                                      nl_a, nl_b, nl_c, nl_d, &
    8354             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    8355             :                                      primitives, &
    8356             :                                      buffer1, buffer2)
    8357             : #else
    8358             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    8359             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    8360             :                                         sphi_a, &
    8361             :                                         sphi_b, &
    8362             :                                         sphi_c, &
    8363             :                                         sphi_d, &
    8364             :                                         primitives, &
    8365         350 :                                         buffer1, buffer2)
    8366             : #endif
    8367             :                CASE (4)
    8368             : #if __MAX_CONTR > 4 || __MAX_CONTR == 4
    8369             :                   CALL contract_fpdg(work, &
    8370             :                                      nl_a, nl_b, nl_c, nl_d, &
    8371             :                                      sphi_a, sphi_b, sphi_c, sphi_d, &
    8372             :                                      primitives, &
    8373             :                                      buffer1, buffer2)
    8374             : #else
    8375             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    8376             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    8377             :                                         sphi_a, &
    8378             :                                         sphi_b, &
    8379             :                                         sphi_c, &
    8380             :                                         sphi_d, &
    8381             :                                         primitives, &
    8382           0 :                                         buffer1, buffer2)
    8383             : #endif
    8384             :                CASE DEFAULT
    8385             :                   CALL contract_generic(ncoa, ncob, ncoc, ncod, nsoa, nsob, nsoc, nsod, &
    8386             :                                         work, nl_a, nl_b, nl_c, nl_d, &
    8387             :                                         sphi_a, &
    8388             :                                         sphi_b, &
    8389             :                                         sphi_c, &
    8390             :                                         sphi_d, &
    8391             :                                         primitives, &
    8392        5659 :                                         buffer1, buffer2)
    8393             :                END SELECT
    8394             :             CASE (3)
    8395        2949 :                SELECT CASE (n_d)
    8396             :                CASE (0)
    8397             : #if __MAX_CONTR > 3 || __MAX_CONTR == 3
    8398             :                   CALL contract_fpfs(work, &