namespace eval ::ModeD:: {

   #
   # ModeD.tcl startet 21.09.2003 by CyBex, last updated 15.07.2004
   #
   # any problems or suggestions? write to Script-ModeD@CyBex.has.nolife.org
   #
   # This Script is written for one channel only and its only for the
   # www.QuakeNET.org channel mode +D .. it scan for new joining users
   # and give them +v (do visible without talk) .. or kick user that
   # found in the banlist or have the +k flag. Ant an auto-limit is included
   # to see, how many user are at moment online :-)
   #
   # You can see this script work in #berlin and #news.de @ QuakeNet
   #
   # Feel free to change this script, but please submit me your changes :-)
   #
   # Version 0.4.x is testet with Eggdrop 1.6.16 and TCL 8.3
   # Version 0.3.x is testet with Eggdrop 1.6.15 and 1.6.16 on TCL 8.3
   #
   # Changes in 0.3.81
   # + added delay and change a little the random
   # + improved autolimiter
   # Release 0.3.47
   #
   # config

   #how much higher
   set ::ModeD::fasttimer 1
   set ::ModeD::userandom 0
   set ::ModeD::usedelay 0
   set ::ModeD::random 1
   set ::ModeD::delay 1
   set ::ModeD::raiselimit 5
   #time in minutes to change the limit
   set ::ModeD::uplimitticks 8
   set ::ModeD::downlimitticks 16

   set ::ModeD::DoExtStats 1

   #save stats 0/1 and path to data dir, or create "data" in your eggdrop folder
   set ::ModeD::savestats 0
   set ::ModeD::datadir data

   set ::ModeD::uselimiter 0
   set ::ModeD::minlimiter 0

   #wait for the first modechange
   set ::ModeD::netsplitnow 1
   set ::ModeD::netsplitlast [expr [clock seconds]-7000]

   # switch debug by default on/off
   if {![info exists ::ModeD::debug]} { set ::ModeD::debug 0 }

   #my special settings ;)
   set ::ModeD::channel #berlin
   if {$::username=="Newsflash"} {
      set ::ModeD::savestats 0
      set ::ModeD::raiselimit 5
      set ::ModeD::uplimitticks 1
      set ::ModeD::downlimitticks 60
      set ::ModeD::channel #news.de
      set ::ModeD::uselimiter 0
   } elseif {$::username=="b0rk"} {
      set ::ModeD::channel #b0rk.de
      set ::ModeD::uplimitticks 1440
      set ::ModeD::downlimitticks 1
      set ::ModeD::savestats 0
      set ::ModeD::uselimiter 1
   } elseif {$::username=="b0rkBerlin"} {
      set ::ModeD::userandom 0
      set ::ModeD::usedelay 1
      set ::ModeD::random 1
      set ::ModeD::delay 5
      set ::ModeD::uplimitticks 360
      set ::ModeD::downlimitticks 360
      set ::ModeD::uselimiter 1
      set ::ModeD::minlimiter 101
   } elseif {$::username=="Berlin"} {
      set ::ModeD::userandom 0
      set ::ModeD::usedelay 1
      set ::ModeD::random 1
      set ::ModeD::delay 5
      set ::ModeD::uplimitticks 300
      set ::ModeD::downlimitticks 300
      set ::ModeD::uselimiter 1
      set ::ModeD::minlimiter 101
   } elseif {$::username=="Dev-L"} {
      set ::ModeD::raiselimit 10
      set ::ModeD::uplimitticks 8640
      set ::ModeD::downlimitticks 8640
      set ::ModeD::uselimiter 0
      set ::ModeD::minlimiter 0
      set ::ModeD::fasttimer 1
      set ::ModeD::channel #tcl
      #set ::ModeD::channel #news.de
      set ::ModeD::savestats 0
      set ::ModeD::debug 0
   } elseif {$::username=="20mark"} {
      set ::ModeD::userandom 0
      set ::ModeD::random 59
      set ::ModeD::savestats 0
      set ::ModeD::raiselimit 3
      set ::ModeD::uplimitticks 1440
      set ::ModeD::downlimitticks 1440
      set ::ModeD::channel #GrandPrixLegends
   } elseif {$::username=="plain" || $::username=="jump"} {
      set ::ModeD::raiselimit 5
      set ::ModeD::uplimitticks 8640
      set ::ModeD::downlimitticks 8640
      set ::ModeD::uselimiter 1
      set ::ModeD::minlimiter 101
      #set ::ModeD::fasttimer 1
      set ::ModeD::channel #tcl
      #set ::ModeD::channel #news.de
      set ::ModeD::savestats 0
      set ::ModeD::debug 0
   } elseif {$::username=="Chatter"} {
      set ::ModeD::DoExtStats 1
   } else {
      set ::ModeD::DoExtStats 1
   }

   # data

   ## helper

   ## main

   ### vars

   set ::ModeD::develop 0
   if {$::username=="Dev-L" || $::username=="b0rkBerlin" || $::username=="Berlin"} { set ::ModeD::develop 1 }

   set ::ModeD::major 0
   set ::ModeD::minor 4
   if {![info exist ::ModeD::build] || !$::ModeD::develop} { set ::ModeD::build 1 } { incr ::ModeD::build }
   if {![info exist ::ModeD::run]} { set ::ModeD::run 1 } { incr run }
   set ::lateststable 0.4.1
   #first edit:
   #last edit:

   ### helper

   if {$debug} { putcmdlog "Warning! Debug Mode ist \002ON\002!" }
   if {$::lateststable!="$major.$minor.$build"} { if $develop { putcmdlog "Warning! Developer Mode \002ON\002! Latest stable: $::lateststable" } { putcmdlog "Warning! Unstable Version! Latest stable: $::lateststable" } }

   variable joinlist [list]
   variable partlist [list]

   ### binds
   bind raw - 311 ::ModeD::raw311
   bind raw - 324 ::ModeD::raw324
   bind raw - 355 ::ModeD::raw355
   bind raw - 366 ::ModeD::raw366
   bind pubm - "$::ModeD::channel *" ::ModeD::countwords;
   bind splt - * ::ModeD::netsplit:splitsomewhere
   bind splt - "$::ModeD::channel *" ::ModeD::netsplit:split
   bind rejn - * ::ModeD::netsplit:rejoinsomewhere
   bind rejn - "$::ModeD::channel *" ::ModeD::netsplit:rejoin
   bind mode - "$::ModeD::channel *" ::ModeD::Mode
   bind mode - "$::ModeD::channel +l" ::ModeD::ModeL
   bind mode - "$::ModeD::channel -l" ::ModeD::ModeL2
   bind time - "*" ::ModeD::time:check

   ### procs

   proc onchan {nick {chan ""}} {
      if {$chan!=""} {
         putcmdlog "onchan ModeD: [expr [lsearch -exact [string tolower $::ModeD::onlinelist] [string tolower $nick]]!=-1 || [::onchan $nick $chan]]"
         return [expr [lsearch -exact [string tolower $::ModeD::onlinelist] [string tolower $nick]]!=-1 || [::onchan $nick $chan]]
      } {
         putcmdlog "onchan ModeD: [expr [lsearch -exact [string tolower $::ModeD::onlinelist] [string tolower $nick]]!=-1 || [::onchan $nick]]"
         return [expr [lsearch -exact [string tolower $::ModeD::onlinelist] [string tolower $nick]]!=-1 || [::onchan $nick]]
      }
   }

   #### helper
   
   set ::lmdmsg ""

   proc loadfile {name args} {
      if {$::ModeD::debug} { putcmdlog "load $name" }
      if [info exists name] {
         set fh [open $name r]
         set gets [gets $fh]
         close $fh
         return $gets
      }
   }
   proc savefile {name data} {
      if {$::ModeD::debug} { putcmdlog "save $name" }
      set fh [open $name w]
      puts $fh $data
      close $fh
   }
   proc appendfile {name data} {
      if [info exists name] {
         if {$::ModeD::debug} { putcmdlog "append $name" }
         set fh [open $name a]
         puts $fh $data
         close $fh
      } {
         save $name $data
      }
   }

   proc debug:makedummy {} {
      proc adddebug {args} {}
      proc putdebug {args} {}
   }

   if ![info exists ::ModeD::Statistik(Init)] {set ::ModeD::Statistik(Init) 0} {incr ::ModeD::Statistik(Init)}
   if ![info exists ::ModeD::Statistik(Netsplit)] {set ::ModeD::Statistik(Netsplit) 0}
   if ![info exists ::ModeD::Statistik(Rejoin)] {set ::ModeD::Statistik(Rejoin) 0}
   if ![info exists ::ModeD::Statistik(WPM)] {set ::ModeD::Statistik(WPM) 0}
   if ![info exists ::ModeD::Statistik(LPM)] {set ::ModeD::Statistik(LPM) 0}

   if [info exist ::ModeD::debug] {
      if $::ModeD::debug {
         if [info exist debug:buffer] { set debug:buffer [list] }
         proc adddebug {args} {
            if {[lindex $args 0]=="-newline"} {
               lappend ::ModeD::debug:buffer [lrange $args 1 end]
            } {
               set ::ModeD::debug:buffer [lreplace $::ModeD::debug:buffer end end [set args "[lindex $::ModeD::debug:bufer end]${args}"]]
            }
         }
         proc putdebug {args} {
            foreach line $::ModeD:buffer {
               putcmdlog $line
            }
            set debug:buffer [list]
            if {$args!=[list]} {
               putcmdlog [join $args]
            }
         }
      } { debug:makedummy }
   } { debug:makedummy }

   if {![info exists ::ModeD::onlinelist]} 	{ set ::ModeD::onlinelist [list] }
   if {![info exists ::ModeD::userlist]} 		{ set ::ModeD::userlist [list] }
   if {![info exists ::ModeD::voicelist]} 	{ set ::ModeD::voicelist [list] }
   if {![info exists ::ModeD::kicklist]} 		{ set ::ModeD::kicklist [list] }
   if {![info exists ::ModeD::authlist]} 		{ set ::ModeD::authlist [list] }

   proc user:add {mask} {
   #if $::ModeD::debug { putcmdlog " u:a start : $mask" }
      set found 0
      if ![info exist ::ModeD::userlist] {set ::ModeD::userlist [list]}
      ## ulist
      set num 0; foreach {name last first} $::ModeD::userlist {
         set time [expr [unixtime]-$last]
         if {$time>895 && !$::ModeD::develop || $time>895 && $::ModeD::develop} {
            if $::ModeD::debug { putcmdlog "user:add: nick $name last [duration $time] deleted" }
            # ulist
            set ::ModeD::userlist [lreplace $ModeD::userlist $num [expr $num+2]]
         } { incr num 2 }
      }
      set found 0;
      # ulist
      foreach {name time first} $::ModeD::userlist {
         if {$name==$mask || [string equal $mask $name]} {set fifa $first; set found 1; break}
      }
      # ulist
      if {![info exi fifa]} {set fifa [unixtime]}
      if !$found {
         lappend ::ModeD::userlist $mask
         lappend ::ModeD::userlist [expr [unixtime]+20-[rand 60]]
         lappend ::ModeD::userlist $fifa
         # ulist
      }
      return $found
   }

   #### main

   proc raw311 {args} {
      if $::ModeD::debug { putcmdlog " r311 start : $args" }
      if ![info exist ::ModeD::voicelist] {set ::ModeD::voicelist [list]}
      if ![info exist ::ModeD::kicklist] {set ::ModeD::kicklist [list]}
      set nick [lindex [split [lindex $args 2]] 1]
      set ident [lindex [split [lindex $args 2]] 2]
      set host [lindex [split [lindex $args 2]] 3]
      set mask $nick!$ident@$host
      set hand [finduser $mask]
      set chattr [chattr $hand $::ModeD::channel]
      if {[set num [lsearch -exact $::ModeD::joinlist $nick]]!=-1} {
         putcmdlog "\002join311\002 $nick!$ident@$host ($hand) $chattr"
         if {[info command spamscan:join]!=""} {
            spamscan:join $nick $ident@$host [nick2hand $nick] $::ModeD::channel
         }
         set ::ModeD::joinlist [lreplace $::ModeD::joinlist $num $num]
         if {$::username=="b0rkBerlin"} {
         if {[info command getchanlogin]=="getchanlogin"} {
	         putmsg #cybex.test "\002join311\002 $nick!$ident@$host ($hand) A:\[[getchanlogin $nick]\] C:$chattr"
	      } {
	         putmsg #cybex.test "\002join311\002 $nick!$ident@$host ($hand) C:$chattr"
	      }
	      }
      } {
      #putcmdlog "!join311 $nick!$ident@$host ($hand) $chattr"
      }
      set banlist [list]
      if {![info exist ::ModeD::users($nick)]} {set ::ModeD::users($nick) $mask}
      if {[banlist]!=[list]} { lappend banlist [banlist] }
      if {[banlist $::ModeD::channel]!=[list]} { lappend banlist [banlist $::ModeD::channel] }
      set num 0; foreach item $banlist { foreach ban $item {
            incr num
            if {[string match -nocase [list [lindex $ban 0]] $mask]} {
               if {[lsearch -exact $::ModeD::kicklist $mask] == -1} {
                  putcmdlog "add $nick to kicklist / match banlist $num / string match [list [lindex $ban 0]] $mask [string match [list [lindex $ban 0]] $mask]"
                  lappend ::ModeD::kicklist $mask
                  lappend ::ModeD::kicklist [lindex $ban 1]
               } { putcmdlog "$nick is allready on kicklist 1" }
            }
      } }
      if {$::username=="b0rk" && $::ModeD::channel=="#b0rk.de" && ( $host=="b0rk.de" || $host=="217.160.128.86" || $host=="nolife.org" || $host=="82.165.15.22" ) } {
         if {[lsearch -exact $::ModeD::voicelist $nick]==-1} {
            putcmdlog "add $nick to voicelist (b0rk)"
            lappend ::ModeD::voicelist $nick
         }
      }
      if {$hand!="*"} {
         if {[matchattr $hand q|C $::ModeD::channel] && [lsearch -exact [string tolower $::ModeD::onlinelist] [string tolower $nick]]!=-1 && ( $::username=="Berlin" || $::username=="Dev-L" ) } {
            putcmdlog "voice $nick .. webchat ol:[lsearch -exact [string tolower $::ModeD::onlinelist] [string tolower $nick]]!=-1 oc:[onchan $nick $::ModeD::channel]  v:[isvoice $nick $::ModeD::channel]"
            set ::ModeD::webchat 1
         }

         if {(([matchattr $hand q|C $::ModeD::channel] && ( $::username=="Berlin" || $::username=="Dev-L" ) ) || ([matchattr $hand v|gv $::ModeD::channel])) && ![isop $nick $::ModeD::channel] && ![isvoice $nick $::ModeD::channel] } {
            if {[lsearch -exact $::ModeD::voicelist $nick] == -1} {
               putcmdlog "add $nick to voicelist (q|C) c:[chattr $hand] m:[matchattr $hand q|C $::ModeD::channel]"
               lappend ::ModeD::voicelist $nick
            }
         }
         if {[matchattr $hand v|gv $::ModeD::channel] && ![isop $nick $::ModeD::channel] && ![isvoice $nick $::ModeD::channel] } {
            if {[lsearch -exact $::ModeD::voicelist $nick] == -1} {
               putcmdlog "add $nick to voicelist v|gv c:[chattr $hand] m:[matchattr $hand v|gv $::ModeD::channel]"
               lappend ::ModeD::voicelist $nick
            }
         }
         if {[matchattr $hand k|k $::ModeD::channel]} {
            if {[lsearch -exact $::ModeD::kicklist $mask] == -1} {
               putcmdlog "add $nick to kicklist / match +k flag"
               lappend ::ModeD::kicklist $mask
               lappend ::ModeD::kicklist "banned"
            } { putcmdlog "$nick is allready on kicklist 2" }
         }
      }
   }
   proc raw324 {args} {
      variable lastmodetime [clock seconds]
      variable lastmode [lindex [lindex $args 2] 2]
   }
   proc raw355 {args} {
      if $::ModeD::debug { putcmdlog " r355 start : $args" }
      if ![info exist ::ModeD::raw355:timestamp] {set ::ModeD::raw355:timestamp [clock sec]}
      if {[expr [clock sec]-${::ModeD::raw355:timestamp}]<=3} {set onlyadd 1 } \
      else {set onlyadd 0; set ::ModeD::raw355:timestamp [clock sec] }
      set whois ""; set skip "";
      set users [lindex [split [lindex $args 2] :] 1]
      if ![info exist ::ModeD::newonlinelist] {set ::ModeD::newonlinelist [list]}
      if !$onlyadd {
      #putcmdlog "clear newonlinelist"
         set ::ModeD::newonlinelist [list]
         foreach user [array names ::ModeD::users] { unset ::ModeD::users($user) }
      }
      foreach user [split $users] {
         if [string eq -noc fishbot $user] continue
         set found [user:add $user]
         if $::ModeD::debug { putcmdlog " r355 found $found : user:add $user" }
         ###
         if $found { lappend skip $user } {
            lappend whois $user;
            #if {[info command getchanlogin]==""} {
            if {![string eq -noc $user "fishbot"] && [string trim $user]!=""} {
               puthelp [subst -nocommands -nobackslashes {WHOIS $user}]
            }
            #}
         }
         if ![info exist ::ModeD::newonlinelist] {set ::ModeD::newonlinelist [list]}
         if {[info exist ::ModeD::newonlinelist] && [lsearch -exact $::ModeD::newonlinelist $user]==-1} {
            lappend ::ModeD::newonlinelist $user
         }
      }
      set tot [llength [chanlist $::ModeD::channel]]
      #putcmdlog "newonlinelist has now [set onl [llength $::ModeD::newonlinelist]] users ([expr $tot+$onl] total) \[[expr $tot+[llength $::ModeD::onlinelist]]\]"
      if {[info command getchanlogin]!="" && $whois!=[list]} {puthelp "WHO [join $whois ","] n%hnua" -next}
      if ![info exist ::ModeD::statuscounter] { set ::ModeD::statuscounter 0 } { incr ::ModeD::statuscounter }
      set text "\002whois:\002$whois \002skip:\002$skip"
      set text [string map -nocase {{cybex} {C*B*x} {never} {n*v*r} {securetohopethatneverthiswordcomes} {andthisonetwoorbettertoorevenbettertoo} {die} {d**}} $text]
      set ::ModeD::checktext $::ModeD::newonlinelist
      if ![info exist ::ModeD::lastwhoistext] { set ::ModeD::lastwhoistext "" }
      if { ( $::ModeD::statuscounter>="15" && ( $whois!="" || $skip!="" ) ) && [string length $::ModeD::checktext] != [string length $::ModeD::lastwhoistext]} {
         set ::ModeD::statuscounter 0;
         set ::ModeD::lastwhoistext $::ModeD::checktext
      } {
         if {$whois!="" || $skip!=""} {
            if $::ModeD::debug {
               putcmdlog "$text"
            }
         }
      }
   }

   proc raw366 {args} {
      if $::ModeD::debug { putcmdlog " r366 start : $args" }
      set join [list]; set part [list]
      if [info exi ::ModeD::newonlinelist] {set ::ModeD::onlinelist $::ModeD::newonlinelist; unset ::ModeD::newonlinelist}
      if ![info exi ::ModeD::last366onlinelist] {set ::ModeD::last366onlinelist [list]}
      if ![info exi ::ModeD::joinlist] {set ::ModeD::joinlist [list]}
      if ![info exi ::ModeD::partlist] {set ::ModeD::partlist [list]}
      foreach u $::ModeD::onlinelist {
         if {[lsearch -exact $::ModeD::last366onlinelist $u]==-1} {
            lappend join $u
            putcmdlog "\002add join\002: $u h:[getchanhost $u]"
         }
      }
      foreach u $::ModeD::last366onlinelist {
         if {[lsearch -exact $::ModeD::onlinelist $u]==-1} {lappend part $u}
      }
      if {$join!=[list] || $part!=[list] || 0} {putcmdlog "\002userlist\002: [expr [llength $::ModeD::userlist]/3]   \002onlinelist\002: [llength $::ModeD::onlinelist]   \002join\002: $join   \002part\002: $part"}
      set ::ModeD::last366onlinelist $::ModeD::onlinelist
      foreach u $join {if {[lsearch -exact $::ModeD::joinlist $u]} {lappend ::ModeD::joinlist $u}}
      foreach u $part {if {[lsearch -exact $::ModeD::partlist $u]} {lappend ::ModeD::partlist $u}}
      #if {$join!=[list] || $part!=[list] || 0} {putcmdlog "\002userlist\002: [expr [llength $::ModeD::userlist]/2]   \002onlinelist\002: [llength $::ModeD::onlinelist]   \002join\002: $join   \002part\002: $part"}
      #putcmdlog $::ModeD::userlist
   }
   proc getnames {chan} {
      variable lastmode
      variable lastnamestime
      if ![info exist lastmode] {set lastmode "+"}
      if {$lastmode=="+"} {getmodes $chan}
      if ![info exist lastnamestime] {set lastnamestime [expr [clock seconds]-9]}
      #if $::ModeD::debug { putcmdlog " 0 getnames : NAMES -d $::ModeD::channel // [expr [clock second]-$lastnamestime]>9 && [string match +*D* $lastmode] || [string match +*d* $lastmode] // $lastmode" }
      if {[expr [clock second]-$lastnamestime]>9 && [string match +*D* $lastmode] || [string match +*d* $lastmode]} {

         #if $::ModeD::debug { putcmdlog " getnames : NAMES -d $::ModeD::channel" }
	#putcmdlog "get names in 5 secs"
	if {[info command isinvisible]==""} {
	         utimer 5 [list puthelp "NAMES -d $::ModeD::channel"]	         
	         set lastnamestime [clock seconds]
	  }
      }
   }
   proc getmodes {chan} {
      variable lastmodetime
      if ![info exist lastmodetime] {set lastmodetime [expr [clock seconds]-900]}
      if {[expr [clock second]-$lastmodetime]>899} {
      #putcmdlog "MODE get"
         utimer 5 [list puthelp "MODE $chan"]
         set lastmodetime [clock seconds]
      }
   }

   proc countwords {nick host hand chan text} {
      if ![info exists ::ModeD::Statistik(WPM)] {set ::ModeD::Statistik(WPM) 0} {incr ::ModeD::Statistik(WPM) [llength [split $text]]}
      if ![info exists ::ModeD::Statistik(LPM)] {set ::ModeD::Statistik(LPM) 0} {incr ::ModeD::Statistik(LPM)}
   }

   proc netsplit:splitsomewhere {nick args} {
      putserv "MODE $::ModeD::channel -l ( ll:$::ModeD::lastlimit )" ;
      if {$::ModeD::develop && $::lmdmsg!="cls"} {set ::lmdmsg "cls"; putcmdlog "Netsplit somewhere, Clear Limit "}
      set ::ModeD::lastlimit [expr $::ModeD::lastlimit-25]
      set ::ModeD::lastlimittick 0
      set ::ModeD::netsplitnow 1
      if ![info exist ::ModeD::netsplitlast] {
         set ::ModeD::netsplitlast [expr [clock seconds]-3600]
      }
      #putcmdlog "Netsplit somewhere"
   }
   proc netsplit:split {nick args} {
   #putserv "MODE $::ModeD::channel -l" ; if {$::ModeD::develop} {putcmdlog "Clear Limit"}
      if {$::ModeD::develop && $::lmdmsg!="cl"} {set ::lmdmsg "cl"; putcmdlog "Netsplit, Clear Limit ( ll:$::ModeD::lastlimit ul:[expr [llength [chanlist $::ModeD::channel]]+[llength $::ModeD::userlist]/3+$::ModeD::raiselimit] ol:[expr [llength [chanlist $::ModeD::channel]]+[llength $::ModeD::onlinelist]+$::ModeD::raiselimit] )"}
      set ::ModeD::lastlimit [expr $::ModeD::lastlimit-25]
      set ::ModeD::lastlimittick 0
      set ::ModeD::netsplitnow 1
      set ::ModeD::netsplitlast [clock seconds]
      set found [user:add $nick]
      putcmdlog "Netsplit now"
      if ![info exists ::ModeD::Statistik(Netsplit)] {set ::ModeD::Statistik(Netsplit) 0} {incr ::ModeD::Statistik(Netsplit)}
   }
   proc netsplit:rejoinsomewhere {nick args} {
      if [info exist ::ModeD::netsplitnow] {
         if {$::ModeD::develop && $::lmdmsg!="rjs"} {set ::lmdmsg "rjs"; putcmdlog "rejoin somewhere [info exist ::ModeD::netsplitnow]"}
         set ::ModeD::netsplitlast [expr [clock seconds]-6900]
         putcmdlog "Netjoin in next 5 minutes"
      }
   }
   proc netsplit:rejoin {nick args} {
      if {$::ModeD::develop && $::lmdmsg!="rj"} {set ::lmdmsg "rj"; putcmdlog "rejoin [info exist ::ModeD::netsplitnow]"}
      if ![info exists ::ModeD::Statistik(Rejoin)] {set ::ModeD::Statistik(Rejoin) 0} {incr ::ModeD::Statistik(Rejoin)}
      if ![info exist ::ModeD::userlist] {set ::ModeD::userlist [list]}
      set num [lsearch -exact $::ModeD::userlist $nick]
      if [info exist ::ModeD::netsplitnow] {
         putcmdlog "Netjoin now"
         unset ::ModeD::netsplitnow ::ModeD::netsplitlast
      }
      if {$num!="-1"} {
      	 # ulist
         set ::ModeD::userlist [lreplace $::ModeD::userlist $num [expr $num+2]]
      }
      set ::ModeD::lastlimit 101
   }

   proc Mode {nick host hand chan mc victim} {
      ModeD::getmodes $chan
   }
   proc ModeL {nick host hand chan mc victim} {
      if {![string equal -no $chan $::ModeD::channel]} {return}
      if {$nick!=$::botnick && $::ModeD::develop} {set ::lmdmsg "ms"; putcmdlog "MODE Change $chan $mc $victim by $nick ( set ll:$::ModeD::lastlimit ul:[expr [llength [chanlist $::ModeD::channel]]+[llength $::ModeD::userlist]/3+$::ModeD::raiselimit] ol:[expr [llength [chanlist $::ModeD::channel]]+[llength $::ModeD::onlinelist]+$::ModeD::raiselimit] ) "}
      set ::ModeD::lastlimit $victim
      set ::ModeD::lastlimittick 0
      utimer 5 [list ModeD::getnames $::ModeD::channel]
   }
   proc ModeL2 {nick host hand chan mc victim} {
      if {![string equal -no $chan $::ModeD::channel]} {return}
      if {$nick!=$::botnick && $::ModeD::develop} {set ::lmdmsg "mc"; putcmdlog "MODE Change $chan $mc by $nick (clear ll:$::ModeD::lastlimit ul:[expr [llength [chanlist $::ModeD::channel]]+[llength $::ModeD::userlist]/3+$::ModeD::raiselimit] ol:[expr [llength [chanlist $::ModeD::channel]]+[llength $::ModeD::onlinelist]+$::ModeD::raiselimit] )"}
      set ::ModeD::lastlimittick 0
      utimer 5 [list ModeD::getnames $::ModeD::channel]
      set ::ModeD::lastlimit [expr $::ModeD::lastlimit-25]
      set ::ModeD::netsplitnow 1
      if ![info exist ::ModeD::netsplitlast] {
         set ::ModeD::netsplitlast [expr [clock seconds]-3600]
      }
   }

   proc time:doit {args} {
      utimer 5 [list ModeD::getnames $::ModeD::channel]
      if {[lindex $args 0]=="23" && [lindex $args 1]=="59"} {
         set ::ModeD::kicklist [list]
         set ::ModeD::voicelist [list]
      }
      if ![info exist ::ModeD::userlist] {set ::ModeD::userlist [list]}
      if ![info exist ::ModeD::kicklist] {set ::ModeD::kicklist [list]}
      if ![info exist ::ModeD::voicelist] {set ::ModeD::voicelist [list]}

      set ucount [expr [llength [chanlist $::ModeD::channel]]+[llength $::ModeD::onlinelist]]
      set limit [expr $ucount+$::ModeD::raiselimit]
      if {$limit<$::ModeD::minlimiter} {set limit $::ModeD::minlimiter}
      if ![info exist ::ModeD::lastlimit] {set ::ModeD::lastlimit 0}
      if ![info exist ::ModeD::lastlimittick] {set ::ModeD::lastlimittick 0}

      #remove dead nicks
      foreach checknick $::ModeD::voicelist {
         if {[lsearch -exact $::ModeD::onlinelist $checknick]==-1 && ([isvoice $checknick $ModeD::channel] || ![onchan $checknick $ModeD::channel])} {
            set removenum [lsearch -exact $::ModeD::voicelist $checknick]
            set ::ModeD::voicelist [lreplace $::ModeD::voicelist $removenum $removenum]
            set removenum [lsearch -exact $::ModeD::voicelist $checknick]
            putcmdlog "remove $checknick from voicelist"
         }
      }
      if ![info exists ::ModeD::LastKickNick] {set ::ModeD::LastKickNick [list]}
      foreach {checkmask checktype} $::ModeD::kicklist {
         putcmdlog "DEBUG: Check Mask $checkmask Type $checktype"
         set cknick [lindex [split $checkmask !] 0]
         set ckhand [nick2hand $cknick]
         putcmdlog "kicklist [lsearch -exact [split [string tolower [join $::ModeD::onlinelist]]] [list [string tolower $cknick]]] = [lindex $::ModeD::onlinelist [lsearch -exact [split [string tolower [join $::ModeD::onlinelist]]] [list [string tolower $cknick]]]] = $cknick"
         putcmdlog "kicklist [lsearch -exact [split [string tolower [join $::ModeD::onlinelist]]] [string tolower $cknick]] = [lindex $::ModeD::onlinelist [lsearch -exact [split [string tolower [join $::ModeD::onlinelist]]] [string tolower $cknick]]] = $cknick / match on \[nicks] "
         if {[string match -nocase *@b0rk.de $checkmask] || [string match -nocase *@217.160.128.86 $checkmask] || [matchattr $ckhand bnm] } {
            set removenum [lsearch -exact $::ModeD::kicklist $checkmask]
            set ::ModeD::kicklist [lreplace $::ModeD::kicklist $removenum [expr 1+$removenum]]
            continue
         }
         if {[lsearch -exact [split [string tolower [join $::ModeD::onlinelist]]] [string tolower $cknick]]==-1} {
            set removenum [lsearch -exact $::ModeD::kicklist $checkmask]
            set ::ModeD::kicklist [lreplace $::ModeD::kicklist $removenum [expr 1+$removenum]]
            putcmdlog "REMOVE $removenum $cknick from kicklist"
         }
         if {[lsearch -exact [split [string tolower [join $::ModeD::LastKickNick]]] [string tolower $cknick]]!=-1} {
            set removenum2 [lsearch -exact [split [string tolower [join $::ModeD::LastKickNick]]] [string tolower $cknick]]
            putcmdlog "CHK KICKLIST [lindex $::ModeD::LastKickNick $removenum2] DUR [duration [expr [unixtime]-[lindex $::ModeD::LastKickNick [expr 1+$removenum2]]]] [expr [unixtime]-[lindex $::ModeD::LastKickNick [expr 1+$removenum2]]]"
            if {[expr [unixtime]-[lindex $::ModeD::LastKickNick [expr 1+$removenum2]]]>598} {
               set removenum [lsearch -exact $::ModeD::kicklist $checkmask]
               putcmdlog "remove $removenum [lindex $::ModeD::kicklist $removenum]"
               set ::ModeD::kicklist [lreplace $::ModeD::kicklist $removenum [expr 1+$removenum]]

            }
         }
      }
      foreach {checkmask checktype} $::ModeD::kicklist {
         set cknick [lindex [split $checkmask !] 0]; set ckhand [nick2hand $cknick]
         if {[string match -nocase *@b0rk.de $checkmask] || [string match -nocase *@217.160.128.86 $checkmask] || [matchattr $ckhand bnm] } {
            putcmdlog "its b0rk, a bot or master, ignore $cknick ($ckhand) - [string match -nocase *@b0rk.de $checkmask] || [string match -nocase *@217.160.128.86 $checkmask] || [matchattr $ckhand bnm]"
            continue
         }

         if {[lsearch -exact [split [string tolower [join $::ModeD::onlinelist]]] [string tolower $cknick]]!=-1} {
            putcmdlog " 1 online $cknick chekcne [lsearch -exact [split [string tolower [join $::ModeD::onlinelist]]] [string tolower $cknick]] [lindex $::ModeD::onlinelist [lsearch -exact [split [string tolower [join $::ModeD::onlinelist]]] [string tolower $cknick]]]"
            if {[lsearch -exact [split [string tolower [join $::ModeD::LastKickNick]]] [string tolower $cknick]]!=-1} {
               putcmdlog " 2 kick $cknick [lsearch -exact [split [string tolower [join $::ModeD::LastKickNick]]] [string tolower $cknick]] [lindex $::ModeD::LastKickNick [lsearch -exact [split [string tolower [join $::ModeD::LastKickNick]]] [string tolower $cknick]]]"
               if [string match -nocase *.users.quakenet.org $checkmask] {
                  set banmask *!*@[lindex [split $checkmask @] 1]
               } {
                  set banmask [maskhost $checkmask]
               }
               putlog "BAN $::ModeD::channel +b $banmask // $checkmask"
               puthelp "MODE $::ModeD::channel +b $banmask"
            }
            putlog "KICK $cknick $::ModeD::channel :$checktype"
            puthelp "KICK $::ModeD::channel $cknick :$checktype"
            lappend ::ModeD::LastKickNick $cknick
            lappend ::ModeD::LastKickNick [unixtime]
            putcmdlog "LastKickNick(s) [llength $::ModeD::LastKickNick]"

         }
      }
      foreach {cknick dtime} $::ModeD::LastKickNick {
         if {[expr [unixtime]-$dtime]>600} {
            putcmdlog "set Num [lsearch -exact [split [string tolower [join $::ModeD::LastKickNick]]] [list [string tolower $cknick]]] [lindex $::ModeD::LastKickNick [lsearch -exact [split [string tolower [join $::ModeD::LastKickNick]]] [list [string tolower $cknick]]]]"
            set Num [lsearch -exact [split [string tolower [join $::ModeD::LastKickNick]]] [string tolower $cknick]]
            if {$Num!=-1} {
               set ::ModeD::LastKickNick [lreplace $::ModeD::LastKickNick $Num [expr $Num+1]]
            }
            putcmdlog "Remove $cknick from LastKickNicks $Num - LastKickNicks ([llength $::ModeD::LastKickNick])"
         }
      }
      set minutes [string trimleft [lindex $args 0] 0]; if {$minutes==""} {set minutes 0}
      if {$minutes % 1==0 && [channel get $::ModeD::channel statuslog]} {
         putcmdlog "uc $ucount / limit $limit / lastlimit $::ModeD::lastlimit / llt $::ModeD::lastlimittick // $::ModeD::lastlimit<[expr $limit-($::ModeD::raiselimit-2)] ([expr $::ModeD::lastlimit<[expr $limit-($::ModeD::raiselimit-2)]]) / $::ModeD::lastlimit>[expr $limit+($::ModeD::raiselimit+2)] ([expr $::ModeD::lastlimit>[expr $limit+($::ModeD::raiselimit+2)]]) / $::ModeD::lastlimit>[expr $limit+($::ModeD::raiselimit-2)] ([expr $::ModeD::lastlimit>[expr $limit+($::ModeD::raiselimit-2)]])"
      }
      #work on cy:allbefore to 20031030
      if {([expr $::ModeD::lastlimit<[expr $limit-($::ModeD::raiselimit-2)]] || [expr $::ModeD::lastlimit>[expr $limit+($::ModeD::raiselimit+2)]])} {
      #putcmdlog "|| ($::ModeD::voicelist != [list] && ($::ModeD::lastlimit<[expr $limit-($::ModeD::raiselimit-2)] || $::ModeD::lastlimit>[expr $limit+($::ModeD::raiselimit+2)])) // ([expr $::ModeD::lastlimit<[expr $limit-($::ModeD::raiselimit-2)]] || [expr $::ModeD::lastlimit>[expr $limit+($::ModeD::raiselimit+2)]]) // ll:$::ModeD::lastlimit l:$limit ol:[expr [llength [chanlist $::ModeD::channel]]+[llength $::ModeD::onlinelist]+$::ModeD::raiselimit] || tick:$::ModeD::lastlimittick up:$::ModeD::uplimitticks dn:$::ModeD::downlimitticks ||"
      }
      #putcmdlog [subst {expr $::ModeD::uselimiter && $::ModeD::voicelist != [list] && ( [llength $::ModeD::voicelist] >= 4 || [lindex $args 0]=="00" || [lindex $args 0]=="15" || [lindex $args 0]=="30" || [lindex $args 0]=="45") || ( $::ModeD::voicelist != [list] && ( ( $::ModeD::lastlimit<$limit && $::ModeD::lastlimittick>=$::ModeD::uplimitticks ) || ( $::ModeD::lastlimit>$limit && $::ModeD::lastlimittick>=$::ModeD::downlimitticks ) ) ) || ($::ModeD::voicelist != [list] && ($::ModeD::lastlimit<[expr $limit-($::ModeD::raiselimit-2)] || $::ModeD::lastlimit>[expr $limit+($::ModeD::raiselimit+2)])) }]
      if {
         $::ModeD::uselimiter
         &&
         $::ModeD::voicelist != [list]
         &&
         (
         [llength $::ModeD::voicelist] >= 4 || [string match "?0" [lindex $args 0]] || [string match "?5" [lindex $args 0]] || [lindex $args 0]=="30" || [lindex $args 0]=="45"
         )
         ||
         (
         [info exist ::ModeD::webchat] && $::ModeD::webchat && $::ModeD::voicelist != [list]
         )
         ||
         (
         $::ModeD::voicelist != [list]
         &&
         (
         (
         $::ModeD::lastlimit<$limit
         &&
         $::ModeD::lastlimittick>=$::ModeD::uplimitticks
         )
         ||
         (
         $::ModeD::lastlimit>$limit
         &&
         $::ModeD::lastlimittick>=$::ModeD::downlimitticks
         )
         )
         )
         ||
         (
         $::ModeD::voicelist != [list]
         &&
         (
         $::ModeD::lastlimit<[expr $limit-($::ModeD::raiselimit-2)]
         ||
         $::ModeD::lastlimit>[expr $limit+($::ModeD::raiselimit-2)]
         )
         )
      } {
      #if {$::ModeD::voicelist != [list]}
         if {$::ModeD::uselimiter && $::ModeD::lastlimit!=$limit && $::ModeD::lastlimittick!=0 && ![info exist ::ModeD::netsplitnow]} {
            putcmdlog "VOICELIST-LIMIT: $limit $::ModeD::voicelist"
            foreach {a b c d e} $::ModeD::voicelist {
               set ::lmdmsg "lv";
               puthelp "MODE $::ModeD::channel +lvvvvv $limit $a $b $c $d $e"
               putcmdlog "MODE $::ModeD::channel +lvvvvv $limit $a $b $c $d $e ( ll:$::ModeD::lastlimit ul:[expr [llength [chanlist $::ModeD::channel]]+[llength $::ModeD::userlist]/3+$::ModeD::raiselimit] ol:[expr [llength [chanlist $::ModeD::channel]]+[llength $::ModeD::onlinelist]+$::ModeD::raiselimit] )"
            }
            set ::ModeD::voicelist [list]

            set ::ModeD::lastlimit $limit
            set ::ModeD::lastlimittick 0
            if $::ModeD::develop { putcmdlog "set ::ModeD::lastlimittick to 0 - $limit/$::ModeD::lastlimit - $args" }

         } {
            putcmdlog "VOICELIST: $::ModeD::voicelist"
            foreach {a b c d e f} $::ModeD::voicelist {
               puthelp "MODE $::ModeD::channel +vvvvvv $a $b $c $d $e $f"
               putcmdlog "MODE $::ModeD::channel +vvvvvv $a $b $c $d $e $f"
            }
            set ::ModeD::voicelist [list]
         }
      }
      if {$minutes % 1==0 && [channel get $::ModeD::channel statuslog]} {
         putcmdlog "$::ModeD::uselimiter && ![info exist ::ModeD::netsplitnow] && ( ( ( $::ModeD::lastlimit<$limit && $::ModeD::lastlimittick>=$::ModeD::uplimitticks ) || ( $::ModeD::lastlimit>$limit && $::ModeD::lastlimittick>=$::ModeD::downlimitticks ) ) || (($::ModeD::lastlimit<[expr $limit-($::ModeD::raiselimit-2)] || $::ModeD::lastlimit>[expr $limit+($::ModeD::raiselimit-2)])) ) "
      }
      if {$::ModeD::uselimiter && ![info exist ::ModeD::netsplitnow] && ( ( ( $::ModeD::lastlimit<$limit && $::ModeD::lastlimittick>=$::ModeD::uplimitticks ) || ( $::ModeD::lastlimit>$limit && $::ModeD::lastlimittick>=$::ModeD::downlimitticks ) ) || (($::ModeD::lastlimit<[expr $limit-($::ModeD::raiselimit-2)] || $::ModeD::lastlimit>[expr $limit+($::ModeD::raiselimit-2)])) ) } {
         if {[expr {${::ModeD::lastlimit}-$limit}]<=($::ModeD::raiselimit*2)} {
            putcmdlog "set limit from $::ModeD::lastlimit to $limit after [duration [expr $::ModeD::lastlimittick*60]] [info exist ::ModeD::netsplitnow] [info exist ::ModeD::netsplitlast] "
            set ::ModeD::lastlimit $limit
            set ::lmdmsg "pm";
            putcmdlog "set Limit in time:doit (pushmode ll:$::ModeD::lastlimit l:$limit ul:[expr [llength [chanlist $::ModeD::channel]]+[llength $::ModeD::userlist]/3+$::ModeD::raiselimit] ol:[expr [llength [chanlist $::ModeD::channel]]+[llength $::ModeD::onlinelist]+$::ModeD::raiselimit] )"
            pushmode $::ModeD::channel +l $limit
            set ::ModeD::lastlimittick 0
            if $::ModeD::develop { putcmdlog "set ::ModeD::lastlimittick to 0 - $limit/$::ModeD::lastlimit - $args" }
         } {
            putcmdlog "difference to \002big\002 to lower the limit: ${::ModeD::lastlimit} - $limit == [expr {${::ModeD::lastlimit}-$limit}] ($::ModeD::raiselimit)"
            set ::ModeD::lastlimit 0
            set ::ModeD::lastlimittick 0
            pushmode $::ModeD::channel -l
		      set ::ModeD::netsplitnow 1
            if ![info exist ::ModeD::netsplitlast] {
                     set ::ModeD::netsplitlast [expr [clock seconds]-300]
            }
                           

         }
      } {
         incr ::ModeD::lastlimittick
         if $::ModeD::debug { putcmdlog "incr ::ModeD::lastlimittick to $::ModeD::lastlimittick - $limit/$::ModeD::lastlimit - $args" }
      }

      #später ersetzen durch if ::ModeD::savestat
      if {$::ModeD::savestats} {

         if {[llength $args]>=5} {
            set fname $::ModeD::datadir/day.$::nick.[lindex $args 4].[lindex $args 3].[lindex $args 2]
            set lname $::ModeD::datadir/last.$::nick
            set op 0; set voice 0; set visit 0;
            foreach user [chanlist $::ModeD::channel] {
               if [isop $user $::ModeD::channel] { incr op } elseif [isvoice $user $::ModeD::channel] { incr voice } { incr visit }
            }
            set data [list]
            lappend data [lindex $args 1]
            lappend data [lindex $args 0]
            lappend data [expr [llength [chanlist $::ModeD::channel]]+[llength $::ModeD::onlinelist]]
            lappend data $op
            lappend data $voice
            lappend data $visit
            lappend data [llength $::ModeD::onlinelist]
            lappend data [expr [llength $::ModeD::userlist]/3]
            lappend data $::ModeD::lastlimittick
            lappend data $limit
            lappend data $::ModeD::lastlimit
            lappend data [expr [llength $::ModeD::kicklist]/2]
            lappend data [expr [llength $::ModeD::voicelist]]
            if {$::ModeD::DoExtStats} {
               lappend data $::ModeD::Statistik(Netsplit)
               lappend data $::ModeD::Statistik(Rejoin)
               set WPM $::ModeD::Statistik(WPM); lappend data $::ModeD::Statistik(WPM); set ::ModeD::Statistik(WPM) 0
               set LPM $::ModeD::Statistik(LPM); lappend data $::ModeD::Statistik(LPM); set ::ModeD::Statistik(LPM) 0
            }
            #putcmdlog "[llength $args]==5 || [llength $args]>=5 && [string trimleft [lindex $args 6] 0]==\"\" [expr {[llength $args]==5 || [llength $args]>=5 && [string trimleft [lindex $args 5] 0]==""}]  5:[lindex $args 5] 6:[lindex $args 6]"
            if {[llength $args]==5 || [llength $args]>=5 && [string trimleft [lindex $args 5] 0]==""} {
               appendfile $fname $data
            }
            savefile $lname $data
         }
      }

	# ulist
      set num 0; foreach {name last first} $::ModeD::userlist {
         set time [expr [unixtime]-$last]
         if {$time>895} {
         #set num [lsearch $::ModeD::userlist $name];
            if $::ModeD::debug {
               putcmdlog "time:doit: nick $name last [duration $time] deleted"
            }
            # ulist
            set ::ModeD::userlist [lreplace $ModeD::userlist $num [expr $num+2]]
         } { incr num 2 }
      }
   }
   proc time:check {arg1 arg2 arg3 arg4 arg5} {
      if $::ModeD::fasttimer {
         utimer 50 [list [namespace current]::time:check:utimer $arg1 $arg2 $arg3 $arg4 $arg5 50]
         utimer 40 [list [namespace current]::time:check:utimer $arg1 $arg2 $arg3 $arg4 $arg5 40]
         utimer 30 [list [namespace current]::time:check:utimer $arg1 $arg2 $arg3 $arg4 $arg5 30]
         utimer 20 [list [namespace current]::time:check:utimer $arg1 $arg2 $arg3 $arg4 $arg5 20]
         utimer 10 [list [namespace current]::time:check:utimer $arg1 $arg2 $arg3 $arg4 $arg5 10]
      }
      time:check:utimer $arg1 $arg2 $arg3 $arg4 $arg5 00
   }
   proc time:check:utimer {arg1 arg2 arg3 arg4 arg5 args} {
      if {[info exist ::ModeD::netsplitnow] && [info exist ::ModeD::netsplitlast]} {
         set ::ModeD::netsplitnow [expr (7200-([clock seconds]-$::ModeD::netsplitlast))/60]
         if {[expr $::ModeD::netsplitnow % 10] == 4} {
            putcmdlog "Wait [duration [expr 7260-([clock seconds]-$::ModeD::netsplitlast)]] ([expr [clock seconds]-$::ModeD::netsplitlast]) for netsplit end"
         }
      }
      if {[info exist ::ModeD::netsplitnow] && [info exist ::ModeD::netsplitlast] && [expr [clock seconds]-$::ModeD::netsplitlast]>7200} {
         putcmdlog "Remove netsplit, too old / [expr [clock seconds]-$::ModeD::netsplitlast]>7200 / [expr [expr [clock seconds]-$::ModeD::netsplitlast]>7200]"
         unset ::ModeD::netsplitlast ::ModeD::netsplitnow
      }
      if {$::ModeD::userandom} {set time [expr [rand $::ModeD::random]+1]} \
      elseif {$::ModeD::usedelay} {set time $::ModeD::delay} {set time 1}
      set cmd [list ::ModeD::time:doit $arg1 $arg2 $arg3 $arg4 $arg5 $args]
      #if {$::ModeD::userandom || $::ModeD::usedelay && $::ModeD::debug} {putcmdlog "utimer $time $cmd"}
      if {$::ModeD::userandom || $::ModeD::usedelay} {utimer $time $cmd} {eval $cmd}
   }

   proc main {args} {
   }

   ### init

   proc init {args} {
      set err [catch {main $args} msg]
      return [list $err $msg]
   }

   set init [init]

}

# proc fixes for me
proc lol_whois_reply {args} {}
proc lol_whois_unknow {args} {}

namespace eval ::ModeD:: {

   #set ::ModeD::develop 0

   putlog "ModeD.tcl loaded version $major.$minor.$build.$run"
   return "$major.$minor.$build.$run"
}


set ::lmdmsg ""