text:
c -------------------------------------------------------------------- c
c ------ This and the following subroutines read in the spectrum ----- c
c ------ file given in the SUSY Les Houches Accord format        ----- c
c ------ hep-ph/0311123.                                         ----- c
c ------ Thanks to Tilman Plehn for the first version which has  ----- c
c ------ been expanded and changed here.                         ----- c
c -------------------------------------------------------------------- c

      subroutine SLHA_read_leshouches_HDEC(ninlha)

      implicit double precision (a-h,m,o-z)
      double precision minval(1:20),smval(1:30),massval(1:50),
     .                 nmixval(4,4),umixval(2,2),vmixval(2,2),
     .                 stopmixval(2,2),sbotmixval(2,2),staumixval(2,2),
     .                 hmixval(1:10),gaugeval(1:3),msoftval(1:100),
     .                 auval(3,3),adval(3,3),aeval(3,3),yuval(3,3),
     .                 ydval(3,3),yeval(3,3),qvalue(1:20),extval(0:100)
      double precision tuval(3,3),tdval(3,3),teval(3,3)
      double precision vckmval(4)
      integer check(1:22),check_final,imod(1:2)
      character line1*6,line2*100,
     .          spinfo1*100,spinfo2*100,modselval*100,mincom(1:20)*20,
     .          extcom(0:100)*20,softcom(1:100)*20,hmixcom(1:10)*20
      logical done

      COMMON/SLHA_leshouches1_HDEC/spinfo1,spinfo2,modselval,mincom,
     .                             extcom,softcom,hmixcom
      COMMON/SLHA_leshouches2_HDEC/minval,extval,smval,massval,nmixval,
     .                      umixval,vmixval,stopmixval,sbotmixval,
     .                      staumixval,hmixval,gaugeval,msoftval,auval,
     .                      adval,aeval,yuval,ydval,yeval,alphaval,
     .                      qvalue,imod
      COMMON/SLHA_leshouches3_HDEC/vckmval
      COMMON/SLHA_checkval_HDEC/check

c -- start from the beginning of the file SLHA_leshouches.in --
      rewind(ninlha)

c -- initialization of the check array --
      do i1=1,22,1
         check(i1) = 0
      end do

c -- the scale Q --
      do i=1,20,1
         qvalue(i) = 0.D0
      end do

c a trick to jump over undefined parameters in subsequent writings
      unlikely = -123456789D0
      do i=1,100,1
         extval(i-1) = unlikely
      end do
      do i=1,20,1
         minval(i) = unlikely
      end do
      do i=1,10,1
         hmixval(i) = unlikely
      end do
      do i=1,100,1
         msoftval(i) = unlikely
      end do
      do i=1,3,1
       do j=1,3,1
         auval(i,j) = unlikely
         adval(i,j) = unlikely
         aeval(i,j) = unlikely
       end do
      end do
      do i=1,4,1
         vckmval(i) = unlikely
      end do

c ------------------------------------------------------------------- c
      do i=1,10000,1

c -- check if routine can be left --
         check_final = 1
         do i1=1,22,1
            check_final = check_final*check(i1)
         end do
         if(check_final.eq.1) then
            return
         endif

c -- read in new line --
         line1=' '
         read(ninlha,'(a6,a100)',end=9900,err=9900) line1,line2

c -- rewrite line1(1:6) and line2(1:20) to upper case --
         do j1=1,6,1
            if(line1(j1:j1).ne.'#') then
               do j2=97,122,1
                  if(line1(j1:j1).eq.char(j2)) line1(j1:j1)=char(j2-32)
               end do
            endif
         end do

         do j1=1,20,1
            if(line2(j1:j1).ne.'#') then
               do j2=97,122,1
                  if(line2(j1:j1).eq.char(j2)) line2(j1:j1)=char(j2-32)
               end do
            endif
         end do

c -- looks for blocks and reads them in one after the other --
         if(line1(1:1).eq.'B') then

c -- look for Block MODSEL --
            if(line2(1:6).eq.'MODSEL') then
               call SLHA_READ_MODSEL_HDEC(ninlha,modselval,imod,done)
               if (done) then
                  check(1) = 1
                  goto 1111
               else
                  print*,'SLHA_read_leshouches: problem in MODSEL'
               endif

c -- look for Block SMINPUTS --
            elseif(line2(1:8).eq.'SMINPUTS') then
               call SLHA_READ_SMINPUTS_HDEC(ninlha,smval,done)
               if (done) then
                  check(2) = 1
                  goto 1111
               else
                  print*,'SLHA_read_leshouches: problem in SMINPUTS'
               endif

c -- look for Block MINPAR --
            elseif(line2(1:6).eq.'MINPAR') then
               call SLHA_READ_MINPAR_HDEC(ninlha,minval,mincom,done)
               if (done) then
                  check(3) = 1
                  goto 1111
               else
                  print*,'SLHA_read_leshouches: problem in MINPAR'
               endif

c -- look for Block EXTPAR --
            elseif(line2(1:6).eq.'EXTPAR') then
               call SLHA_READ_EXTPAR_HDEC(ninlha,extval,extcom,done)
               if (done) then
                  check(4) = 1
                  goto 1111
               else
                  print*,'SLHA_read_leshouches: problem in EXTPAR'
               endif

c -- look for Block MASS --
            elseif(line2(1:4).eq.'MASS') then
               call SLHA_READ_MASS_HDEC(ninlha,massval,done)
               if (done) then
                  check(5) = 1
                  goto 1111
               else
                  print*,'SLHA_read_leshouches: problem in MASS'
               endif

c -- look for Block NMIX --
            elseif(line2(1:4).eq.'NMIX') then
               call SLHA_READ_NMIX_HDEC(ninlha,nmixval,done)
               if (done) then
                  check(6) = 1
                  goto 1111
               else
                  print*,'SLHA_read_leshouches: problem in NMIX'
               endif

c -- look for Block UMIX --
            elseif(line2(1:4).eq.'UMIX') then
               call SLHA_READ_UMIX_HDEC(ninlha,umixval,done)
               if (done) then
                  check(7) = 1
                  goto 1111
               else
                  print*,'SLHA_read_leshouches: problem in UMIX'
               endif

c -- look for Block VMIX --
            elseif(line2(1:4).eq.'VMIX') then
               call SLHA_READ_VMIX_HDEC(ninlha,vmixval,done)
               if (done) then
                  check(8) = 1
                  goto 1111
               else
                  print*,'SLHA_read_leshouches: problem in VMIX'
               endif

c -- look for Block STOPMIX --
            elseif(line2(1:7).eq.'STOPMIX') then
               call SLHA_READ_STOPMIX_HDEC(ninlha,stopmixval,done)
               if (done) then
                  check(9) = 1
                  goto 1111
               else
                  print*,'SLHA_read_leshouches: problem in STOPMIX'
               endif

c -- look for Block SBOTMIX --
            elseif(line2(1:7).eq.'SBOTMIX') then
               call SLHA_READ_SBOTMIX_HDEC(ninlha,sbotmixval,done)
               if (done) then
                  check(10) = 1
                  goto 1111
               else
                  print*,'SLHA_read_leshouches: problem in SBOTMIX'
               endif

c -- look for Block STAUMIX --
            elseif(line2(1:7).eq.'STAUMIX') then
               call SLHA_READ_STAUMIX_HDEC(ninlha,staumixval,done)
               if (done) then
                  check(11) = 1
                  goto 1111
               else
                  print*,'SLHA_read_leshouches: problem in STAUMIX'
               endif

c -- look for Block ALPHA --
            elseif(line2(1:5).eq.'ALPHA') then
               call SLHA_READ_ALPHA_HDEC(ninlha,alphaval,done)
               if (done) then
                  check(12) = 1
                  goto 1111
               else
                  print*,'SLHA_read_leshouches: problem in ALPHA'
               endif

c -- look for Block HMIX --
            elseif(line2(1:4).eq.'HMIX') then
c              backspace ninlha
c              read(ninlha,'(16x,E16.8)') Qval
               call readQval(ninlha,Qval)
               qvalue(1) = Qval
               call SLHA_READ_HMIX_HDEC(ninlha,hmixval,hmixcom,done)
               if (done) then
                  check(13) = 1
                  goto 1111
               else
                  print*,'SLHA_read_leshouches: problem in HMIX'
               endif

c -- look for Block GAUGE --
            elseif(line2(1:5).eq.'GAUGE') then
c              backspace ninlha
c              read(ninlha,'(16x,E16.8)') Qval
               call readQval(ninlha,Qval)
               qvalue(2) = Qval
               call SLHA_READ_GAUGE_HDEC(ninlha,gaugeval,done)
               if (done) then
                  check(14) = 1
                  goto 1111
               else
                  print*,'SLHA_read_leshouches: problem in GAUGE'
               endif

c -- look for Block MSOFT --
            elseif(line2(1:5).eq.'MSOFT') then
c              backspace ninlha
c              read(ninlha,'(16x,E16.8)') Qval
               call readQval(ninlha,Qval)
               qvalue(3) = Qval
               call SLHA_READ_MSOFT_HDEC(ninlha,msoftval,softcom,done)
               if (done) then
                  check(15) = 1
                  goto 1111
               else
                  print*,'SLHA_read_leshouches: problem in MSOFT'
               endif

c -- look for Block AU --
            elseif(line2(1:2).eq.'AU') then
c              backspace ninlha
c              read(ninlha,'(13x,E16.8)') Qval
               call readQval(ninlha,Qval)
               qvalue(4) = Qval
               call SLHA_READ_AU_HDEC(ninlha,auval,done)
               if (done) then
                  check(16) = 1
                  goto 1111
               else
                  print*,'SLHA_read_leshouches: problem in AU'
               endif

c -- look for Block AD --
            elseif(line2(1:2).eq.'AD') then
c              backspace ninlha
c              read(ninlha,'(13x,E16.8)') Qval
               call readQval(ninlha,Qval)
               qvalue(5) = Qval
               call SLHA_READ_AD_HDEC(ninlha,adval,done)
               if (done) then
                  check(17) = 1
                  goto 1111
               else
                  print*,'SLHA_read_leshouches: problem in AD'
               endif

c -- look for Block AE --
            elseif(line2(1:2).eq.'AE') then
c              backspace ninlha
c              read(ninlha,'(13x,E16.8)') Qval
               call readQval(ninlha,Qval)
               qvalue(6) = Qval
               call SLHA_READ_AE_HDEC(ninlha,aeval,done)
               if (done) then
                  check(18) = 1
                  goto 1111
               else
                  print*,'SLHA_read_leshouches: problem in AE'
               endif

c -- look for Block YU --
            elseif(line2(1:2).eq.'YU') then
c              backspace ninlha
c              read(ninlha,'(13x,E16.8)') Qval
               call readQval(ninlha,Qval)
               qvalue(7) = Qval
               call SLHA_READ_YU_HDEC(ninlha,yuval,done)
               if (done) then
                  check(19) = 1
                  goto 1111
               else
                  print*,'SLHA_read_leshouches: problem in YU'
               endif

c -- look for Block YD --
            elseif(line2(1:2).eq.'YD') then
c              backspace ninlha
c              read(ninlha,'(13x,E16.8)') Qval
               call readQval(ninlha,Qval)
               qvalue(8) = Qval
               call SLHA_READ_YD_HDEC(ninlha,ydval,done)
               if (done) then
                  check(20) = 1
                  goto 1111
               else
                  print*,'SLHA_read_leshouches: problem in YD'
               endif

c -- look for Block YE --
            elseif(line2(1:2).eq.'YE') then
c              backspace ninlha
c              read(ninlha,'(13x,E16.8)') Qval
               call readQval(ninlha,Qval)
               qvalue(9) = Qval
               call SLHA_READ_YE_HDEC(ninlha,yeval,done)
               if (done) then
                  check(21) = 1
                  goto 1111
               else
                  print*,'SLHA_read_leshouches: problem in YE'
               endif

c -- look for Block SPINFO --
            elseif(line2(1:6).eq.'SPINFO') then
               call SLHA_READ_SPINFO_HDEC(ninlha,spinfo1,spinfo2,done)
               if (done) then
                  check(22) = 1
                  goto 1111
               else
                  print*,'SLHA_read_leshouches: problem in SPINFO'
               endif

c -- look for Block TUIN --
            elseif(line2(1:4).eq.'TUIN') then
c              backspace ninlha
c              read(ninlha,'(13x,E16.8)') Qval
               call readQval(ninlha,Qval)
               qvalue(4) = Qval
               call SLHA_READ_TUIN_HDEC(ninlha,tuval,done)
               auval(1,1) = tuval(1,1)/smval(22)
               auval(2,2) = tuval(2,2)/smval(24)
               auval(3,3) = tuval(3,3)/smval(6)
               do ii=1,3
                do jj=1,3
                 if(ii.ne.jj)auval(ii,jj)=0
                enddo
               enddo
               if (done) then
                  check(16) = 1
                  goto 1111
               else
                  print*,'SLHA_read_leshouches: problem in TUIN'
               endif

c -- look for Block TDIN --
            elseif(line2(1:4).eq.'TDIN') then
c              backspace ninlha
c              read(ninlha,'(13x,E16.8)') Qval
               call readQval(ninlha,Qval)
               qvalue(5) = Qval
               call SLHA_READ_TDIN_HDEC(ninlha,tdval,done)
               adval(1,1) = tdval(1,1)/smval(21)
               adval(2,2) = tdval(2,2)/smval(23)
               adval(3,3) = tdval(3,3)/smval(5)
               do ii=1,3
                do jj=1,3
                 if(ii.ne.jj)adval(ii,jj)=0
                enddo
               enddo
               if (done) then
                  check(17) = 1
                  goto 1111
               else
                  print*,'SLHA_read_leshouches: problem in TDIN'
               endif

c -- look for Block TEIN --
            elseif(line2(1:4).eq.'TEIN') then
c              backspace ninlha
c              read(ninlha,'(13x,E16.8)') Qval
               call readQval(ninlha,Qval)
               qvalue(6) = Qval
               call SLHA_READ_TEIN_HDEC(ninlha,teval,done)
               aeval(1,1) = teval(1,1)/smval(11)
               aeval(2,2) = teval(2,2)/smval(13)
               aeval(3,3) = teval(3,3)/smval(7)
               do ii=1,3
                do jj=1,3
                 if(ii.ne.jj)aeval(ii,jj)=0
                enddo
               enddo
               if (done) then
                  check(18) = 1
                  goto 1111
               else
                  print*,'SLHA_read_leshouches: problem in TEIN'
               endif

c -- look for Block VCKMIN --
            elseif(line2(1:6).eq.'VCKMIN') then
               call SLHA_READ_VCKMIN_HDEC(ninlha,vckmval,done)
               if (done) then
                  check(2) = 1
                  goto 1111
               else
                  print*,'SLHA_read_leshouches: problem in VCKMIN'
               endif

c -- continue if the Block is not interesting --
            else
               goto 1111
            endif

c -- continue if it is not a Block statement --
         else
            goto 1111
         endif

c -- maximum number of lines exhausted --
 1111    continue
      end do

 9900 print*,'SLHA_read_leshouches: end of file'

      return
      end

c -------------------------------------------------------------------- c

      subroutine SLHA_READ_MODSEL_HDEC(ninlha,modselval,imod,done)

      implicit double precision (a-h,m,o-z)
      integer imod(1:2)
      character line1*1,line2*1,line3*100,modselval*100
      logical done

      done=.false.

      modselval = ' '

      do i=1,200,1
         read(ninlha,'(a1)',end=9900) line1

c -- decide what it is and read the line if anything of interest --
         if (line1.eq.' ') then
            backspace ninlha
            read(ninlha,*) idum1,idum2,line2,line3

            if(idum1.eq.1) then
               imod(1) = idum1
               imod(2) = idum2
               modselval = line3
            endif

         elseif(line1.eq.'#') then
            go to 1111
         elseif(line1.eq.'b'.or.line1.eq.'B'.or.line1.eq.'d'.or.line1.eq
     ..'D') then
            backspace ninlha
            done =.true.
            return
         endif

 1111    continue
      end do

 9900 print*,'SLHA_read_leshouches: end of file'
      done = .true.

      end

c -------------------------------------------------------------------- c

      subroutine SLHA_READ_SMINPUTS_HDEC(ninlha,smval,done)

      implicit double precision (a-h,m,o-z)
      double precision smval(30)
      character line1*1
      logical done

      done=.false.

      do i=1,30,1
         smval(i) = 0.D0
      end do

      do i=1,200,1
         read(ninlha,'(a1)',end=9900) line1

c -- decide what it is and read the line if anything of interest --
         if (line1.eq.' ') then
            backspace ninlha
            read(ninlha,*) idum,val

c -- inverse EM coupling at the Z pole in the MS_bar scheme (with --
c -- five active flavours) --
            if(idum.eq.1) then
               smval(1) = val
c -- G_F, Fermi constant (in units of GeV^-2)
            elseif(idum.eq.2) then
               smval(2) = val
c -- Strong coupling at the Z pole in the MS_bar scheme (with five --
c -- active flavours) --
            elseif(idum.eq.3) then
               smval(3) = val
c -- M_Z, pole mass --
            elseif(idum.eq.4) then
               smval(4) = val
c -- mb(mb)^MS_bar. b quark running mass in the MS_bar scheme --
            elseif(idum.eq.5) then
               smval(5) = val
c -- mt, pole mass --
            elseif(idum.eq.6) then
               smval(6) = val
c -- mtau, pole mass --
            elseif(idum.eq.7) then
               smval(7) = val
            endif

         elseif(line1.eq.'#') then
            go to 1111
         elseif(line1.eq.'b'.or.line1.eq.'B'.or.line1.eq.'d'.or.line1.eq
     ..'D') then
            backspace ninlha
            done =.true.
            return
         endif

 1111    continue
      end do

 9900 print*,'SLHA_read_leshouches: end of file'
      done = .true.

      end

c -------------------------------------------------------------------- c

      subroutine SLHA_READ_MINPAR_HDEC(ninlha,minval,mincom,done)

      implicit double precision (a-h,m,o-z)
      double precision minval(20)
      character line1*1,line2*1,line3*20,mincom(1:20)*20
      logical done

      done= .false.

      do i=1,20,1
         mincom(i) = ' '
      end do

      do i=1,200,1
         read(ninlha,'(a1)',end=9900) line1

c -- decide what it is and read the line if anything of interest --
         if (line1.eq.' ') then
            backspace ninlha
            read(ninlha,*) idum,val,line2,line3

            do ii=1,6,1
               if(idum.eq.ii) then
                  minval(ii) = val
                  mincom(ii) = line3
               endif
            end do

c -- i=3: value for tanbeta(MZ) --

         elseif(line1.eq.'#') then
            goto 1111
         elseif(line1.eq.'b'.or.line1.eq.'B'.or.line1.eq.'d'.or.line1.eq
     ..'D') then
            backspace ninlha
            done = .true.
            return
         endif

 1111    continue
      end do

 9900 print*,'SLHA_read_leshouches: end of file'
      done = .true.

      end

c -------------------------------------------------------------------- c

      subroutine SLHA_READ_EXTPAR_HDEC(ninlha,extval,extcom,done)

      implicit double precision (a-h,m,o-z)
      double precision extval(0:100)
      character line1*1,line2*1,line3*20,extcom(0:100)*20
      logical done

      done= .false.

      do i=1,100,1
         extcom(i-1) = ' '
      end do

      do i=1,200,1
         read(ninlha,'(a1)',end=9900) line1

c -- decide what it is and read the line if anything of interest --
         if (line1.eq.' ') then
            backspace ninlha
            read(ninlha,*) idum,val,line2,line3

            do ii=1,54,1
               if(idum.eq.(ii-1)) then
                  extval(ii-1) = val
                  extcom(ii-1) = line3
               endif
            end do

         elseif(line1.eq.'#') then
            goto 1111
         elseif(line1.eq.'b'.or.line1.eq.'B'.or.line1.eq.'d'.or.line1.eq
     ..'D') then
            backspace ninlha
            done = .true.
            return
         endif

 1111    continue
      end do

 9900 print*,'SLHA_read_leshouches: end of file'
      done = .true.

      end

c -------------------------------------------------------------------- c

      subroutine SLHA_READ_MASS_HDEC(ninlha,massval,done)

      implicit double precision (a-h,m,o-z)
      double precision massval(50)
      character line1*1
      logical done

      done= .false.

      do i=1,50,1
         massval(i) = 0.D0
      end do

      do i=1,200,1
         read(ninlha,'(a1)',end=9900) line1

c -- decide what it is and read the line if anything of interest --
         if (line1.eq.' ') then
            backspace ninlha
            read(ninlha,*) idum,val

c -- value for M_W --
            if(idum.eq.24) then
               massval(1) = val
c -- value for M_h --
            elseif(idum.eq.25) then
               massval(2) = val
c -- value for M_H --
            elseif(idum.eq.35) then
               massval(3) = val
c -- value for M_A --
            elseif(idum.eq.36) then
               massval(4) = val
c -- value for M_H+/- --
            elseif(idum.eq.37) then
               massval(5) = val
c -- value for ~d_L --
            elseif(idum.eq.1000001) then
               massval(6) = val
c -- value for ~d_R --
            elseif(idum.eq.2000001) then
               massval(7) = val
c -- value for ~u_L --
            elseif(idum.eq.1000002) then
               massval(8) = val
c -- value for ~u_R --
            elseif(idum.eq.2000002) then
               massval(9) = val
c -- value for ~s_L --
            elseif(idum.eq.1000003) then
               massval(10) = val
c -- value for ~s_R --
            elseif(idum.eq.2000003) then
               massval(11) = val
c -- value for ~c_L --
            elseif(idum.eq.1000004) then
               massval(12) = val
c -- value for ~c_R --
            elseif(idum.eq.2000004) then
               massval(13) = val
c -- value for ~b_1 --
            elseif(idum.eq.1000005) then
               massval(14) = val
c -- value for ~b_2 --
            elseif(idum.eq.2000005) then
               massval(15) = val
c -- value for ~t_1 --
            elseif(idum.eq.1000006) then
               massval(16) = val
c -- value for ~t_2 --
            elseif(idum.eq.2000006) then
               massval(17) = val
c -- value for ~e_L --
            elseif(idum.eq.1000011) then
               massval(18) = val
c -- value for ~e_R --
            elseif(idum.eq.2000011) then
               massval(19) = val
c -- value for ~nu_eL --
            elseif(idum.eq.1000012) then
               massval(20) = val
c -- value for ~mu_L --
            elseif(idum.eq.1000013) then
               massval(21) = val
c -- value for ~mu_R --
            elseif(idum.eq.2000013) then
               massval(22) = val
c -- value for ~nu_muL --
            elseif(idum.eq.1000014) then
               massval(23) = val
c -- value for ~tau_1 --
            elseif(idum.eq.1000015) then
               massval(24) = val
c -- value for ~tau_2 --
            elseif(idum.eq.2000015) then
               massval(25) = val
c -- value for ~nu_tauL --
            elseif(idum.eq.1000016) then
               massval(26) = val
c -- value for ~g --
            elseif(idum.eq.1000021) then
               massval(27) = val
c -- value for ~chi_10 --
            elseif(idum.eq.1000022) then
               massval(28) = val
c -- value for ~chi_20 --
            elseif(idum.eq.1000023) then
               massval(29) = val
c -- value for ~chi_30 --
            elseif(idum.eq.1000025) then
               massval(30) = val
c -- value for ~chi_40 --
            elseif(idum.eq.1000035) then
               massval(31) = val
c -- value for ~chi_1+ --
            elseif(idum.eq.1000024) then
               massval(32) = val
c -- value for ~chi_2+ --
            elseif(idum.eq.1000037) then
               massval(33) = val
            endif

         elseif(line1.eq.'#') then
            goto 1111
         elseif(line1.eq.'b'.or.line1.eq.'B'.or.line1.eq.'d'.or.line1.eq
     ..'D') then
            backspace ninlha
            done = .true.
            return
         endif

 1111    continue
      end do

 9900 print*,'SLHA_read_leshouches: end of file'
      done = .true.

      end

c -------------------------------------------------------------------- c

      subroutine SLHA_READ_NMIX_HDEC(ninlha,nmixval,done)

      implicit double precision (a-h,m,o-z)
      double precision nmixval(4,4)
      character line1*1
      logical done

      done= .false.

      do i=1,4,1
         do j=1,4,1
            nmixval(i,j) = 0.D0
         end do
      end do

      do i=1,200,1
         read(ninlha,'(a1)',end=9900) line1

c -- decide what it is and read the line if anything of interest --
         if (line1.eq.' ') then
            backspace ninlha
            read(ninlha,*) idum1,idum2,val

c -- the values for the neutralino mixing matrix --
            if(idum1.eq.1.and.idum2.eq.1) then
               nmixval(1,1) = val
            elseif(idum1.eq.1.and.idum2.eq.2) then
               nmixval(1,2) = val
            elseif(idum1.eq.1.and.idum2.eq.3) then
               nmixval(1,3) = val
            elseif(idum1.eq.1.and.idum2.eq.4) then
               nmixval(1,4) = val
            elseif(idum1.eq.2.and.idum2.eq.1) then
               nmixval(2,1) = val
            elseif(idum1.eq.2.and.idum2.eq.2) then
               nmixval(2,2) = val
            elseif(idum1.eq.2.and.idum2.eq.3) then
               nmixval(2,3) = val
            elseif(idum1.eq.2.and.idum2.eq.4) then
               nmixval(2,4) = val
            elseif(idum1.eq.3.and.idum2.eq.1) then
               nmixval(3,1) = val
            elseif(idum1.eq.3.and.idum2.eq.2) then
               nmixval(3,2) = val
            elseif(idum1.eq.3.and.idum2.eq.3) then
               nmixval(3,3) = val
            elseif(idum1.eq.3.and.idum2.eq.4) then
               nmixval(3,4) = val
            elseif(idum1.eq.4.and.idum2.eq.1) then
               nmixval(4,1) = val
            elseif(idum1.eq.4.and.idum2.eq.2) then
               nmixval(4,2) = val
            elseif(idum1.eq.4.and.idum2.eq.3) then
               nmixval(4,3) = val
            elseif(idum1.eq.4.and.idum2.eq.4) then
               nmixval(4,4) = val
            endif

         elseif(line1.eq.'#') then
            goto 1111
         elseif(line1.eq.'b'.or.line1.eq.'B'.or.line1.eq.'d'.or.line1.eq
     ..'D') then
            backspace ninlha
            done = .true.
            return
         endif

 1111    continue
      end do

 9900 print*,'SLHA_read_leshouches: end of file'
      done = .true.

      end

c -------------------------------------------------------------------- c

      subroutine SLHA_READ_UMIX_HDEC(ninlha,umixval,done)

      implicit double precision (a-h,m,o-z)
      double precision umixval(2,2)
      character line1*1
      logical done

      done= .false.

      do i=1,2,1
         do j=1,2,1
            umixval(i,j) = 0.D0
         end do
      end do

      do i=1,200,1
         read(ninlha,'(a1)',end=9900) line1

c -- decide what it is and read the line if anything of interest --
         if (line1.eq.' ') then
            backspace ninlha
            read(ninlha,*) idum1,idum2,val

c -- the values for the chargino mixing matrix U --
            if(idum1.eq.1.and.idum2.eq.1) then
               umixval(1,1) = val
            elseif(idum1.eq.1.and.idum2.eq.2) then
               umixval(1,2) = val
            elseif(idum1.eq.2.and.idum2.eq.1) then
               umixval(2,1) = val
            elseif(idum1.eq.2.and.idum2.eq.2) then
               umixval(2,2) = val
            endif

         elseif(line1.eq.'#') then
            goto 1111
         elseif(line1.eq.'b'.or.line1.eq.'B'.or.line1.eq.'d'.or.line1.eq
     ..'D') then
            backspace ninlha
            done = .true.
            return
         endif

 1111    continue
      end do

 9900 print*,'SLHA_read_leshouches: end of file'
      done = .true.

      end

c -------------------------------------------------------------------- c

      subroutine SLHA_READ_VMIX_HDEC(ninlha,vmixval,done)

      implicit double precision (a-h,m,o-z)
      double precision vmixval(2,2)
      character line1*1
      logical done

      done= .false.

      do i=1,2,1
         do j=1,2,1
            vmixval(i,j) = 0.D0
         end do
      end do

      do i=1,200,1
         read(ninlha,'(a1)',end=9900) line1

c -- decide what it is and read the line if anything of interest --
         if (line1.eq.' ') then
            backspace ninlha
            read(ninlha,*) idum1,idum2,val

c -- the values for the chargino mixing matrix V --
            if(idum1.eq.1.and.idum2.eq.1) then
               vmixval(1,1) = val
            elseif(idum1.eq.1.and.idum2.eq.2) then
               vmixval(1,2) = val
            elseif(idum1.eq.2.and.idum2.eq.1) then
               vmixval(2,1) = val
            elseif(idum1.eq.2.and.idum2.eq.2) then
               vmixval(2,2) = val
            endif

         elseif(line1.eq.'#') then
            goto 1111
         elseif(line1.eq.'b'.or.line1.eq.'B'.or.line1.eq.'d'.or.line1.eq
     ..'D') then
            backspace ninlha
            done = .true.
            return
         endif

 1111    continue
      end do

 9900 print*,'SLHA_read_leshouches: end of file'
      done = .true.

      end

c -------------------------------------------------------------------- c

      subroutine SLHA_READ_STOPMIX_HDEC(ninlha,stopmixval,done)

      implicit double precision (a-h,m,o-z)
      double precision stopmixval(2,2)
      character line1*1
      logical done

      done= .false.

      do i=1,2,1
         do j=1,2,1
            stopmixval(i,j) = 0.D0
         end do
      end do

      do i=1,200,1
         read(ninlha,'(a1)',end=9900) line1

c -- decide what it is and read the line if anything of interest --
         if (line1.eq.' ') then
            backspace ninlha
            read(ninlha,*) idum1,idum2,val

c -- the values for the stop mixing matrix: m(1,1) = cos(theta),     --
c -- m(1,2) = sin(theta), m(2,1) = -sin(theta), m(2,2) = cos(theta). --
            if(idum1.eq.1.and.idum2.eq.1) then
               stopmixval(1,1) = val
            elseif(idum1.eq.1.and.idum2.eq.2) then
               stopmixval(1,2) = val
            elseif(idum1.eq.2.and.idum2.eq.1) then
               stopmixval(2,1) = val
            elseif(idum1.eq.2.and.idum2.eq.2) then
               stopmixval(2,2) = val
            endif

         elseif(line1.eq.'#') then
            goto 1111
         elseif(line1.eq.'b'.or.line1.eq.'B'.or.line1.eq.'d'.or.line1.eq
     ..'D') then
            backspace ninlha
            done = .true.
            return
         endif

 1111    continue
      end do

 9900 print*,'SLHA_read_leshouches: end of file'
      done = .true.

      end

c -------------------------------------------------------------------- c

      subroutine SLHA_READ_SBOTMIX_HDEC(ninlha,sbotmixval,done)

      implicit double precision (a-h,m,o-z)
      double precision sbotmixval(2,2)
      character line1*1
      logical done

      done= .false.

      do i=1,2,1
         do j=1,2,1
            sbotmixval(i,j) = 0.D0
         end do
      end do

      do i=1,200,1
         read(ninlha,'(a1)',end=9900) line1

c -- decide what it is and read the line if anything of interest --
         if (line1.eq.' ') then
            backspace ninlha
            read(ninlha,*) idum1,idum2,val

c -- the values for the sbottom mixing matrix: m(1,1) = cos(theta),  --
c -- m(1,2) = sin(theta), m(2,1) = -sin(theta), m(2,2) = cos(theta). --
            if(idum1.eq.1.and.idum2.eq.1) then
               sbotmixval(1,1) = val
            elseif(idum1.eq.1.and.idum2.eq.2) then
               sbotmixval(1,2) = val
            elseif(idum1.eq.2.and.idum2.eq.1) then
               sbotmixval(2,1) = val
            elseif(idum1.eq.2.and.idum2.eq.2) then
               sbotmixval(2,2) = val
            endif

         elseif(line1.eq.'#') then
            goto 1111
         elseif(line1.eq.'b'.or.line1.eq.'B'.or.line1.eq.'d'.or.line1.eq
     ..'D') then
            backspace ninlha
            done = .true.
            return
         endif

 1111    continue
      end do

 9900 print*,'SLHA_read_leshouches: end of file'
      done = .true.

      end

c -------------------------------------------------------------------- c

      subroutine SLHA_READ_STAUMIX_HDEC(ninlha,staumixval,done)

      implicit double precision (a-h,m,o-z)
      double precision staumixval(2,2)
      character line1*1
      logical done

      done= .false.

      do i=1,2,1
         do j=1,2,1
            staumixval(i,j) = 0.D0
         end do
      end do

      do i=1,200,1
         read(ninlha,'(a1)',end=9900) line1

c -- decide what it is and read the line if anything of interest --
         if (line1.eq.' ') then
            backspace ninlha
            read(ninlha,*) idum1,idum2,val

c -- the values for the stau mixing matrix: m(1,1) = cos(theta),     --
c -- m(1,2) = sin(theta), m(2,1) = -sin(theta), m(2,2) = cos(theta). --
            if(idum1.eq.1.and.idum2.eq.1) then
               staumixval(1,1) = val
            elseif(idum1.eq.1.and.idum2.eq.2) then
               staumixval(1,2) = val
            elseif(idum1.eq.2.and.idum2.eq.1) then
               staumixval(2,1) = val
            elseif(idum1.eq.2.and.idum2.eq.2) then
               staumixval(2,2) = val
            endif

         elseif(line1.eq.'#') then
            goto 1111
         elseif(line1.eq.'b'.or.line1.eq.'B'.or.line1.eq.'d'.or.line1.eq
     ..'D') then
            backspace ninlha
            done = .true.
            return
         endif

 1111    continue
      end do

 9900 print*,'SLHA_read_leshouches: end of file'
      done = .true.

      end

c -------------------------------------------------------------------- c

      subroutine SLHA_READ_ALPHA_HDEC(ninlha,alphaval,done)

      implicit double precision (a-h,m,o-z)
      character line1*1
      logical done

      done= .false.

      alphaval = 0.D0

      do i=1,200,1
         read(ninlha,'(a1)',end=9900) line1

c -- decide what it is and read the line if anything of interest --
         if (line1.eq.' ') then
            backspace ninlha
            read(ninlha,*) val

c -- value for the effective Higgs mixing parameter alpha --
c -- ! The given value is the 'best choice' solution. Depending on  ! --
c -- ! the spectrum calcluator it can be an on-shell parameter or   ! --
c -- ! can be given in the DR_bar definition at a certain           ! --
c -- ! characteristic scale etc. For details on the specific        ! --
c -- ! prescriptions see the manual of the particular spectrum      ! --
c -- ! calculator.                                                  ! --
            alphaval = val

         elseif(line1.eq.'#') then
            goto 1111
         elseif(line1.eq.'b'.or.line1.eq.'B'.or.line1.eq.'d'.or.line1.eq
     ..'D') then
            backspace ninlha
            done = .true.
            return
         endif

 1111    continue
      end do

 9900 print*,'SLHA_read_leshouches: end of file'
      done = .true.

      end

c -------------------------------------------------------------------- c

      subroutine SLHA_READ_HMIX_HDEC(ninlha,hmixval,hmixcom,done)

      implicit double precision (a-h,m,o-z)
      double precision hmixval(1:10)
      character line1*1,line2*1,line3*20,hmixcom(1:10)*20
      logical done

      done= .false.

      do i=1,10,1
         hmixcom(i) = ' '
      end do

      do i=1,200,1
         read(ninlha,'(a1)',end=9900) line1

c -- decide what it is and read the line if anything of interest --
         if (line1.eq.' ') then
            backspace ninlha
            read(ninlha,*) idum,val,line2,line3

            do ii=1,10,1
               if(idum.eq.ii) then
                  hmixval(ii) = val
                  hmixcom(ii) = line3
               endif
            end do

         elseif(line1.eq.'#') then
            goto 1111
         elseif(line1.eq.'b'.or.line1.eq.'B'.or.line1.eq.'d'.or.line1.eq
     ..'D') then
            backspace ninlha
            done = .true.
            return
         endif

 1111    continue
      end do

 9900 print*,'SLHA_read_leshouches: end of file'
      done = .true.

      end

c -------------------------------------------------------------------- c

      subroutine SLHA_READ_GAUGE_HDEC(ninlha,gaugeval,done)

      implicit double precision (a-h,m,o-z)
      double precision gaugeval(1:3)
      character line1*1
      logical done

      done= .false.

      do i=1,3,1
         gaugeval(i) = 0.D0
      end do

      do i=1,200,1
         read(ninlha,'(a1)',end=9900) line1

c -- decide what it is and read the line if anything of interest --
         if (line1.eq.' ') then
            backspace ninlha
            read(ninlha,*) idum,val

c -- The following parameters are the DR_bar running parameters at --
c -- the scale Q.                                                  --
c -- value for g_prime at the scale Q --
            if(idum.eq.1) then
               gaugeval(1) = val

c -- value for g at the scale Q --
            elseif(idum.eq.2) then
               gaugeval(2) = val

c -- value for g3 at the scale Q --
            elseif(idum.eq.3) then
               gaugeval(3) = val
            endif

         elseif(line1.eq.'#') then
            goto 1111
         elseif(line1.eq.'b'.or.line1.eq.'B'.or.line1.eq.'d'.or.line1.eq
     ..'D') then
            backspace ninlha
            done = .true.
            return
         endif

 1111    continue
      end do

 9900 print*,'SLHA_read_leshouches: end of file'
      done = .true.

      end

c -------------------------------------------------------------------- c

      subroutine SLHA_READ_MSOFT_HDEC(ninlha,msoftval,softcom,done)

      implicit double precision (a-h,m,o-z)
      double precision msoftval(1:100)
      character line1*1,line2*1,line3*20,softcom(1:100)*20
      logical done

      done= .false.

      do i=1,100,1
         softcom(i)   = ' '
      end do

      do i=1,200,1
         read(ninlha,'(a1)',end=9900) line1

c -- decide what it is and read the line if anything of interest --
         if (line1.eq.' ') then
            backspace ninlha
            read(ninlha,*) idum,val,line2,line3

            do ii=1,100,1
               if(idum.eq.ii) then
                  msoftval(ii) = val
                  softcom(ii)  = line3
               endif
            end do

         elseif(line1.eq.'#') then
            goto 1111
         elseif(line1.eq.'b'.or.line1.eq.'B'.or.line1.eq.'d'.or.line1.eq
     ..'D') then
            backspace ninlha
            done = .true.
            return
         endif

 1111    continue
      end do

 9900 print*,'SLHA_read_leshouches: end of file'
      done = .true.

      end

c -------------------------------------------------------------------- c

      subroutine SLHA_READ_AU_HDEC(ninlha,auval,done)

      implicit double precision (a-h,m,o-z)
      double precision auval(3,3)
      character line1*1
      logical done

      done= .false.

      do i=1,3,1
         do j=1,3,1
            auval(i,j) = 0.D0
         end do
      end do

      do i=1,200,1
         read(ninlha,'(a1)',end=9900) line1

c -- decide what it is and read the line if anything of interest --
         if (line1.eq.' ') then
            backspace ninlha
            read(ninlha,*) idum1,idum2,val

c -- The following parameters are the DR_bar running parameters at --
c -- the scale Q.                                                  --
c -- values for AU(i,j) at the scale Q --
            if(idum1.eq.1.and.idum2.eq.1) then
               auval(1,1) = val
            elseif(idum1.eq.1.and.idum2.eq.2) then
               auval(1,2) = val
            elseif(idum1.eq.1.and.idum2.eq.3) then
               auval(1,3) = val
            elseif(idum1.eq.2.and.idum2.eq.1) then
               auval(2,1) = val
            elseif(idum1.eq.2.and.idum2.eq.2) then
               auval(2,2) = val
            elseif(idum1.eq.2.and.idum2.eq.3) then
               auval(2,3) = val
            elseif(idum1.eq.3.and.idum2.eq.1) then
               auval(3,1) = val
            elseif(idum1.eq.3.and.idum2.eq.2) then
               auval(3,2) = val
            elseif(idum1.eq.3.and.idum2.eq.3) then
               auval(3,3) = val
            endif

         elseif(line1.eq.'#') then
            goto 1111
         elseif(line1.eq.'b'.or.line1.eq.'B'.or.line1.eq.'d'.or.line1.eq
     ..'D') then
            backspace ninlha
            done = .true.
            return
         endif

 1111    continue
      end do

 9900 print*,'SLHA_read_leshouches: end of file'
      done = .true.

      end

c -------------------------------------------------------------------- c

      subroutine SLHA_READ_AD_HDEC(ninlha,adval,done)

      implicit double precision (a-h,m,o-z)
      double precision adval(3,3)
      character line1*1
      logical done

      done= .false.

      do i=1,3,1
         do j=1,3,1
            adval(i,j) = 0.D0
         end do
      end do

      do i=1,200,1
         read(ninlha,'(a1)',end=9900) line1

c -- decide what it is and read the line if anything of interest --
         if (line1.eq.' ') then
            backspace ninlha
            read(ninlha,*) idum1,idum2,val

c -- The following parameters are the DR_bar running parameters at --
c -- the scale Q.                                                  --
c -- values for AD(i,j) at the scale Q --
            if(idum1.eq.1.and.idum2.eq.1) then
               adval(1,1) = val
            elseif(idum1.eq.1.and.idum2.eq.2) then
               adval(1,2) = val
            elseif(idum1.eq.1.and.idum2.eq.3) then
               adval(1,3) = val
            elseif(idum1.eq.2.and.idum2.eq.1) then
               adval(2,1) = val
            elseif(idum1.eq.2.and.idum2.eq.2) then
               adval(2,2) = val
            elseif(idum1.eq.2.and.idum2.eq.3) then
               adval(2,3) = val
            elseif(idum1.eq.3.and.idum2.eq.1) then
               adval(3,1) = val
            elseif(idum1.eq.3.and.idum2.eq.2) then
               adval(3,2) = val
            elseif(idum1.eq.3.and.idum2.eq.3) then
               adval(3,3) = val
            endif

         elseif(line1.eq.'#') then
            goto 1111
         elseif(line1.eq.'b'.or.line1.eq.'B'.or.line1.eq.'d'.or.line1.eq
     ..'D') then
            backspace ninlha
            done = .true.
            return
         endif

 1111    continue
      end do

 9900 print*,'SLHA_read_leshouches: end of file'
      done = .true.

      end

c -------------------------------------------------------------------- c

      subroutine SLHA_READ_AE_HDEC(ninlha,aeval,done)

      implicit double precision (a-h,m,o-z)
      double precision aeval(3,3)
      character line1*1
      logical done

      done= .false.

      do i=1,3,1
         do j=1,3,1
            aeval(i,j) = 0.D0
         end do
      end do

      do i=1,200,1
         read(ninlha,'(a1)',end=9900) line1

c -- decide what it is and read the line if anything of interest --
         if (line1.eq.' ') then
            backspace ninlha
            read(ninlha,*) idum1,idum2,val

c -- The following parameters are the DR_bar running parameters at --
c -- the scale Q.                                                  --
c -- values for AE(i,j) at the scale Q --
            if(idum1.eq.1.and.idum2.eq.1) then
               aeval(1,1) = val
            elseif(idum1.eq.1.and.idum2.eq.2) then
               aeval(1,2) = val
            elseif(idum1.eq.1.and.idum2.eq.3) then
               aeval(1,3) = val
            elseif(idum1.eq.2.and.idum2.eq.1) then
               aeval(2,1) = val
            elseif(idum1.eq.2.and.idum2.eq.2) then
               aeval(2,2) = val
            elseif(idum1.eq.2.and.idum2.eq.3) then
               aeval(2,3) = val
            elseif(idum1.eq.3.and.idum2.eq.1) then
               aeval(3,1) = val
            elseif(idum1.eq.3.and.idum2.eq.2) then
               aeval(3,2) = val
            elseif(idum1.eq.3.and.idum2.eq.3) then
               aeval(3,3) = val
            endif

         elseif(line1.eq.'#') then
            goto 1111
         elseif(line1.eq.'b'.or.line1.eq.'B'.or.line1.eq.'d'.or.line1.eq
     ..'D') then
            backspace ninlha
            done = .true.
            return
         endif

 1111    continue
      end do

 9900 print*,'SLHA_read_leshouches: end of file'
      done = .true.

      end

c -------------------------------------------------------------------- c

      subroutine SLHA_READ_YU_HDEC(ninlha,yuval,done)

      implicit double precision (a-h,m,o-z)
      double precision yuval(3,3)
      character line1*1
      logical done

      done= .false.

      do i=1,3,1
         do j=1,3,1
            yuval(i,j) = 0.D0
         end do
      end do

      do i=1,200,1
         read(ninlha,'(a1)',end=9900) line1

c -- decide what it is and read the line if anything of interest --
         if (line1.eq.' ') then
            backspace ninlha
            read(ninlha,*) idum1,idum2,val

c -- The following parameters are the DR_bar running parameters at --
c -- the scale Q.                                                  --
c -- values for YU(i,j) at the scale Q --
            if(idum1.eq.1.and.idum2.eq.1) then
               yuval(1,1) = val
            elseif(idum1.eq.1.and.idum2.eq.2) then
               yuval(1,2) = val
            elseif(idum1.eq.1.and.idum2.eq.3) then
               yuval(1,3) = val
            elseif(idum1.eq.2.and.idum2.eq.1) then
               yuval(2,1) = val
            elseif(idum1.eq.2.and.idum2.eq.2) then
               yuval(2,2) = val
            elseif(idum1.eq.2.and.idum2.eq.3) then
               yuval(2,3) = val
            elseif(idum1.eq.3.and.idum2.eq.1) then
               yuval(3,1) = val
            elseif(idum1.eq.3.and.idum2.eq.2) then
               yuval(3,2) = val
            elseif(idum1.eq.3.and.idum2.eq.3) then
               yuval(3,3) = val
            endif

         elseif(line1.eq.'#') then
            goto 1111
         elseif(line1.eq.'b'.or.line1.eq.'B'.or.line1.eq.'d'.or.line1.eq
     ..'D') then
            backspace ninlha
            done = .true.
            return
         endif

 1111    continue
      end do

 9900 print*,'SLHA_read_leshouches: end of file'
      done = .true.

      end

c -------------------------------------------------------------------- c

      subroutine SLHA_READ_YD_HDEC(ninlha,ydval,done)

      implicit double precision (a-h,m,o-z)
      double precision ydval(3,3)
      character line1*1
      logical done

      done= .false.

      do i=1,3,1
         do j=1,3,1
            ydval(i,j) = 0.D0
         end do
      end do

      do i=1,200,1
         read(ninlha,'(a1)',end=9900) line1

c -- decide what it is and read the line if anything of interest --
         if (line1.eq.' ') then
            backspace ninlha
            read(ninlha,*) idum1,idum2,val

c -- The following parameters are the DR_bar running parameters at --
c -- the scale Q.                                                  --
c -- values for YD(i,j) at the scale Q --
            if(idum1.eq.1.and.idum2.eq.1) then
               ydval(1,1) = val
            elseif(idum1.eq.1.and.idum2.eq.2) then
               ydval(1,2) = val
            elseif(idum1.eq.1.and.idum2.eq.3) then
               ydval(1,3) = val
            elseif(idum1.eq.2.and.idum2.eq.1) then
               ydval(2,1) = val
            elseif(idum1.eq.2.and.idum2.eq.2) then
               ydval(2,2) = val
            elseif(idum1.eq.2.and.idum2.eq.3) then
               ydval(2,3) = val
            elseif(idum1.eq.3.and.idum2.eq.1) then
               ydval(3,1) = val
            elseif(idum1.eq.3.and.idum2.eq.2) then
               ydval(3,2) = val
            elseif(idum1.eq.3.and.idum2.eq.3) then
               ydval(3,3) = val
            endif

         elseif(line1.eq.'#') then
            goto 1111
         elseif(line1.eq.'b'.or.line1.eq.'B'.or.line1.eq.'d'.or.line1.eq
     ..'D') then
            backspace ninlha
            done = .true.
            return
         endif

 1111    continue
      end do

 9900 print*,'SLHA_read_leshouches: end of file'
      done = .true.

      end

c -------------------------------------------------------------------- c

      subroutine SLHA_READ_YE_HDEC(ninlha,yeval,done)

      implicit double precision (a-h,m,o-z)
      double precision yeval(3,3)
      character line1*1
      logical done

      done= .false.

      do i=1,3,1
         do j=1,3,1
            yeval(i,j) = 0.D0
         end do
      end do

      do i=1,200,1
         read(ninlha,'(a1)',end=9900) line1

c -- decide what it is and read the line if anything of interest --
         if (line1.eq.' ') then
            backspace ninlha
            read(ninlha,*) idum1,idum2,val

c -- The following parameters are the DR_bar running parameters at --
c -- the scale Q.                                                  --
c -- values for YE(i,j) at the scale Q --
            if(idum1.eq.1.and.idum2.eq.1) then
               yeval(1,1) = val
            elseif(idum1.eq.1.and.idum2.eq.2) then
               yeval(1,2) = val
            elseif(idum1.eq.1.and.idum2.eq.3) then
               yeval(1,3) = val
            elseif(idum1.eq.2.and.idum2.eq.1) then
               yeval(2,1) = val
            elseif(idum1.eq.2.and.idum2.eq.2) then
               yeval(2,2) = val
            elseif(idum1.eq.2.and.idum2.eq.3) then
               yeval(2,3) = val
            elseif(idum1.eq.3.and.idum2.eq.1) then
               yeval(3,1) = val
            elseif(idum1.eq.3.and.idum2.eq.2) then
               yeval(3,2) = val
            elseif(idum1.eq.3.and.idum2.eq.3) then
               yeval(3,3) = val
            endif

         elseif(line1.eq.'#') then
            goto 1111
         elseif(line1.eq.'b'.or.line1.eq.'B'.or.line1.eq.'d'.or.line1.eq
     ..'D') then
            backspace ninlha
            done = .true.
            return
         endif

 1111    continue
      end do

 9900 print*,'SLHA_read_leshouches: end of file'
      done = .true.

      end

c -------------------------------------------------------------------- c

      subroutine SLHA_READ_SPINFO_HDEC(ninlha,spinfo1,spinfo2,done)

      implicit double precision (a-h,m,o-z)
      character line1*1,line2*100,spinfo1*100,spinfo2*100
      logical done

      done= .false.

      spinfo1 = ' '
      spinfo2 = ' '

      do i=1,200,1
         read(ninlha,'(a1)',end=9900) line1

c -- decide what it is and read the line if anything of interest --
         if (line1.eq.' ') then
            backspace ninlha
            read(ninlha,'(1x,i5,3x,a100)') idum,line2

c -- the name of the spectrum calculator --
            if(idum.eq.1) then
               spinfo1 = line2

c -- the version number of the spectrum calculator --
            elseif(idum.eq.2) then
               spinfo2 = line2
            endif

         elseif(line1.eq.'#') then
            goto 1111
         elseif(line1.eq.'b'.or.line1.eq.'B'.or.line1.eq.'d'.or.line1.eq
     ..'D') then
            backspace ninlha
            done = .true.
            return
         endif

 1111    continue
      end do

 9900 print*,'SLHA_read_leshouches: end of file'
      done = .true.

      end

c -------------------------------------------------------------------- c

      subroutine SLHA_READ_TUIN_HDEC(ninlha,auval,done)

      implicit double precision (a-h,m,o-z)
      double precision auval(3,3)
      character line1*1
      logical done

      done= .false.

      do i=1,3,1
         do j=1,3,1
            auval(i,j) = 0.D0
         end do
      end do

      do i=1,200,1
         read(ninlha,'(a1)',end=9900) line1

c -- decide what it is and read the line if anything of interest --
         if (line1.eq.' ') then
            backspace ninlha
            read(ninlha,*) idum1,idum2,val

c -- The following parameters are the DR_bar running parameters at --
c -- the scale Q.                                                  --
c -- values for AU(i,j) at the scale Q --
            if(idum1.eq.1.and.idum2.eq.1) then
               auval(1,1) = val
            elseif(idum1.eq.1.and.idum2.eq.2) then
               auval(1,2) = val
            elseif(idum1.eq.1.and.idum2.eq.3) then
               auval(1,3) = val
            elseif(idum1.eq.2.and.idum2.eq.1) then
               auval(2,1) = val
            elseif(idum1.eq.2.and.idum2.eq.2) then
               auval(2,2) = val
            elseif(idum1.eq.2.and.idum2.eq.3) then
               auval(2,3) = val
            elseif(idum1.eq.3.and.idum2.eq.1) then
               auval(3,1) = val
            elseif(idum1.eq.3.and.idum2.eq.2) then
               auval(3,2) = val
            elseif(idum1.eq.3.and.idum2.eq.3) then
               auval(3,3) = val
            endif

         elseif(line1.eq.'#') then
            goto 1111
         elseif(line1.eq.'b'.or.line1.eq.'B'.or.line1.eq.'d'.or.line1.eq
     ..'D') then
            backspace ninlha
            done = .true.
            return
         endif

 1111    continue
      end do

 9900 print*,'SLHA_read_leshouches: end of file'
      done = .true.

      end

c -------------------------------------------------------------------- c

      subroutine SLHA_READ_TDIN_HDEC(ninlha,adval,done)

      implicit double precision (a-h,m,o-z)
      double precision adval(3,3)
      character line1*1
      logical done

      done= .false.

      do i=1,3,1
         do j=1,3,1
            adval(i,j) = 0.D0
         end do
      end do

      do i=1,200,1
         read(ninlha,'(a1)',end=9900) line1

c -- decide what it is and read the line if anything of interest --
         if (line1.eq.' ') then
            backspace ninlha
            read(ninlha,*) idum1,idum2,val

c -- The following parameters are the DR_bar running parameters at --
c -- the scale Q.                                                  --
c -- values for AD(i,j) at the scale Q --
            if(idum1.eq.1.and.idum2.eq.1) then
               adval(1,1) = val
            elseif(idum1.eq.1.and.idum2.eq.2) then
               adval(1,2) = val
            elseif(idum1.eq.1.and.idum2.eq.3) then
               adval(1,3) = val
            elseif(idum1.eq.2.and.idum2.eq.1) then
               adval(2,1) = val
            elseif(idum1.eq.2.and.idum2.eq.2) then
               adval(2,2) = val
            elseif(idum1.eq.2.and.idum2.eq.3) then
               adval(2,3) = val
            elseif(idum1.eq.3.and.idum2.eq.1) then
               adval(3,1) = val
            elseif(idum1.eq.3.and.idum2.eq.2) then
               adval(3,2) = val
            elseif(idum1.eq.3.and.idum2.eq.3) then
               adval(3,3) = val
            endif

         elseif(line1.eq.'#') then
            goto 1111
         elseif(line1.eq.'b'.or.line1.eq.'B'.or.line1.eq.'d'.or.line1.eq
     ..'D') then
            backspace ninlha
            done = .true.
            return
         endif

 1111    continue
      end do

 9900 print*,'SLHA_read_leshouches: end of file'
      done = .true.

      end

c -------------------------------------------------------------------- c

      subroutine SLHA_READ_TEIN_HDEC(ninlha,aeval,done)

      implicit double precision (a-h,m,o-z)
      double precision aeval(3,3)
      character line1*1
      logical done

      done= .false.

      do i=1,3,1
         do j=1,3,1
            aeval(i,j) = 0.D0
         end do
      end do

      do i=1,200,1
         read(ninlha,'(a1)',end=9900) line1

c -- decide what it is and read the line if anything of interest --
         if (line1.eq.' ') then
            backspace ninlha
            read(ninlha,*) idum1,idum2,val

c -- The following parameters are the DR_bar running parameters at --
c -- the scale Q.                                                  --
c -- values for AE(i,j) at the scale Q --
            if(idum1.eq.1.and.idum2.eq.1) then
               aeval(1,1) = val
            elseif(idum1.eq.1.and.idum2.eq.2) then
               aeval(1,2) = val
            elseif(idum1.eq.1.and.idum2.eq.3) then
               aeval(1,3) = val
            elseif(idum1.eq.2.and.idum2.eq.1) then
               aeval(2,1) = val
            elseif(idum1.eq.2.and.idum2.eq.2) then
               aeval(2,2) = val
            elseif(idum1.eq.2.and.idum2.eq.3) then
               aeval(2,3) = val
            elseif(idum1.eq.3.and.idum2.eq.1) then
               aeval(3,1) = val
            elseif(idum1.eq.3.and.idum2.eq.2) then
               aeval(3,2) = val
            elseif(idum1.eq.3.and.idum2.eq.3) then
               aeval(3,3) = val
            endif

         elseif(line1.eq.'#') then
            goto 1111
         elseif(line1.eq.'b'.or.line1.eq.'B'.or.line1.eq.'d'.or.line1.eq
     ..'D') then
            backspace ninlha
            done = .true.
            return
         endif

 1111    continue
      end do

 9900 print*,'SLHA_read_leshouches: end of file'
      done = .true.

      end

c -------------------------------------------------------------------- c

      subroutine SLHA_READ_VCKMIN_HDEC(ninlha,vckmval,done)

      implicit double precision (a-h,m,o-z)
      double precision vckmval(4)
      character line1*1
      logical done

      done=.false.

      do i=1,4,1
         vckmval(i) = 0.D0
      end do

      do i=1,200,1
         read(ninlha,'(a1)',end=9900) line1

c -- decide what it is and read the line if anything of interest --
         if (line1.eq.' ') then
            backspace ninlha
            read(ninlha,*) idum,val

c -- lambda
            if(idum.eq.1) then
               vckmval(1) = val
c -- A
            elseif(idum.eq.2) then
               vckmval(2) = val
c -- rhobar
            elseif(idum.eq.3) then
               vckmval(3) = val
c -- etabar
            elseif(idum.eq.4) then
               vckmval(4) = val
            endif

         elseif(line1.eq.'#') then
            go to 1111
         elseif(line1.eq.'b'.or.line1.eq.'B'.or.line1.eq.'d'.or.line1.eq
     ..'D') then
            backspace ninlha
            done =.true.
            return
         endif

 1111    continue
      end do

 9900 print*,'SLHA_read_leshouches: end of file'
      done = .true.

      end

      subroutine readQval(ninlha,Qval)
      character buff*100
      integer ninlha,i
      real*8 Qval
      backspace ninlha
      read(ninlha,fmt='(A100)') buff
      do i=1,100
       if(buff(i:i).eq.'=') then
            read(buff(i+1:100),*) Qval
            return
      endif
      enddo
      end

ext: f


text:
!*** Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
!*** See https://llvm.org/LICENSE.txt for license information.
!*** SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
!
! Test recursive calls with pointer arguments
!
module factorize
 type factors
  integer :: x
  type(factors),pointer:: left,right
 end type
contains
 recursive subroutine factor(p,n)
  type(factors),pointer:: p
  integer n
  integer i,j
  allocate(p)
  p%x = n
  nullify(p%left)
  nullify(p%right)
  do i = int(dsqrt(dble(n))),2,-1
   j = n/i
   if( j*i .eq. n )then
    call factor( p%left, j )
    call factor( p%right, i )
    return
   endif
  enddo
 end subroutine
 recursive subroutine fill( p, x, i )
  type(factors) :: p
  integer x(:),i
  if( associated(p%left) .and. associated(p%right) )then
   call fill( p%left, x, i )
   call fill( p%right, x, i )
  else if( associated(p%left) .or. associated(p%right) )then
   print *,'fill: error at ',p%x
   print *,associated(p%left), ' = associated(p%left)'
   print *,associated(p%right), ' = associated(p%right)'
  else
   i = i + 1
   x(i) = p%x
  endif
 end subroutine
 recursive function count( p ) result(res)
  type(factors) :: p
  integer :: res
  if( associated(p%left) .and. associated(p%right) )then
   res = count( p%left )
   res = res + count( p%right )
  else if( associated(p%left) .or. associated(p%right) )then
   print *,'count: error at ',p%x
   print *,associated(p%left), ' = associated(p%left)'
   print *,associated(p%right), ' = associated(p%right)'
   res = 0
  else
   res = 1
  endif
 end function
end module
 use factorize
 type(factors),pointer:: f
 integer,allocatable::x(:)
 integer values(5), nn
 data values / 77, 100, 31, 128, 362880 /
 integer result(10), expect(10)
 data expect / 77, 2, 100, 4, 31, 1, 128, 7, 362880, 13 /
 do i = 1,5
  call factor( f, values(i) )
  n = count( f )
  allocate (x(n))
  nn = 0
  call fill( f, x, nn )
! print *,x
  nn = product(x)
  if( nn .ne. values(i) )then
   print *,nn,' is result, should be ',values(i)
  endif
! print *,nn,n
  result(2*i-1) = nn
  result(2*i) = n
  deallocate (x)     !4/16/2000 - can't allocate if already allocated.
 enddo
 call check( result, expect, 10 )
end

max_stars_repo_name: abrahamtovarmob/flang

max_issues_repo_name: abrahamtovarmob/flang

max_forks_repo_name: abrahamtovarmob/flang


text:
module mod_config

  ! Provides a model configuration structure.

  use mod_kinds, only: ik, rk

  implicit none

  private
  public :: Config, config_from_namelist

  type :: Config
    integer(ik) :: grid_size_x
    integer(ik) :: grid_size_y
    integer(ik) :: num_time_steps
    real(rk) :: time_step
    real(rk) :: grid_spacing_x
    real(rk) :: grid_spacing_y
  end type Config

contains

  function config_from_namelist(filename) result(conf)
    character(len=*), intent(in) :: filename
    type(Config) :: conf
    integer(ik) :: fileunit
    integer(ik) :: grid_size_x, grid_size_y, num_time_steps
    real(rk) :: time_step, grid_spacing_x, grid_spacing_y
    namelist /domain/ grid_size_x, grid_size_y, num_time_steps, time_step, &
                      grid_spacing_x, grid_spacing_y
    open(newunit=fileunit, file=filename, status='old', action='read')
    read(fileunit, nml=domain)
    close(fileunit)
    conf = Config(grid_size_x, grid_size_y, num_time_steps, time_step, &
                  grid_spacing_x, grid_spacing_y)
  end function config_from_namelist

end module mod_config

max_stars_repo_name: AAGAN/tsunami

max_issues_repo_name: AAGAN/tsunami

max_forks_repo_name: AAGAN/tsunami


       SUBROUTINE cross_product(X,Y,Z)

! PURPOSE    :  computation of the cross product of two vectors X and Y

! PARAMETERS :
!         IN :  X(I),I=1,2,3 COMPONENTS OF  X
!               Y(I),I=1,2,3 COMPONENTS OF  Y
!        OUT :  Z(I),I=1,2,3 COMPONENTS OF  Z
!
! AUTHOR     :  Dr. Tzupang Tseng
!
! CREATED    :  01-NOV-2017
!
!
! COPYRIGHT  :  GEOSCIENCE AUSTRALIA
!

       IMPLICIT NONE
       REAL*8       :: X(3),Y(3),Z(3)

! computation of the cross product of two vectros X and Y
! -------------------------------------------------------
       Z(1)=X(2)*Y(3)-X(3)*Y(2)
       Z(2)=X(3)*Y(1)-X(1)*Y(3)
       Z(3)=X(1)*Y(2)-X(2)*Y(1)
       RETURN
       END SUBROUTINE